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: 0x020004A0 RID: 1184
	[Serializable]
	public class IKSolverVR : IKSolver
	{
		// Token: 0x06008B06 RID: 35590 RVA: 0x00239D28 File Offset: 0x00237F28
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 633567, RefRangeEnd = 633568, XrefRangeStart = 633535, XrefRangeEnd = 633567, 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: 0x06008B07 RID: 35591 RVA: 0x00239D84 File Offset: 0x00237F84
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 633583, RefRangeEnd = 633585, XrefRangeStart = 633568, XrefRangeEnd = 633583, 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: 0x06008B08 RID: 35592 RVA: 0x00239DF0 File Offset: 0x00237FF0
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 633600, RefRangeEnd = 633601, XrefRangeStart = 633585, XrefRangeEnd = 633600, 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: 0x06008B09 RID: 35593 RVA: 0x00239E34 File Offset: 0x00238034
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 633601, RefRangeEnd = 633602, XrefRangeStart = 633601, XrefRangeEnd = 633601, 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: 0x06008B0A RID: 35594 RVA: 0x00239E9C File Offset: 0x0023809C
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 633602, XrefRangeEnd = 633604, 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: 0x06008B0B RID: 35595 RVA: 0x00239F04 File Offset: 0x00238104
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 633605, RefRangeEnd = 633606, XrefRangeStart = 633604, XrefRangeEnd = 633605, 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: 0x06008B0C RID: 35596 RVA: 0x00239F6C File Offset: 0x0023816C
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 633609, RefRangeEnd = 633610, XrefRangeStart = 633606, XrefRangeEnd = 633609, 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: 0x06008B0D RID: 35597 RVA: 0x00239FE8 File Offset: 0x002381E8
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 633610, XrefRangeEnd = 633616, 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: 0x06008B0E RID: 35598 RVA: 0x0023A02C File Offset: 0x0023822C
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 633616, XrefRangeEnd = 633623, 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: 0x06008B0F RID: 35599 RVA: 0x0023A07C File Offset: 0x0023827C
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 633623, XrefRangeEnd = 633630, 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: 0x06008B10 RID: 35600 RVA: 0x0023A0CC File Offset: 0x002382CC
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 633630, XrefRangeEnd = 633636, 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: 0x06008B11 RID: 35601 RVA: 0x0023A130 File Offset: 0x00238330
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 633636, XrefRangeEnd = 633642, 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: 0x06008B12 RID: 35602 RVA: 0x0023A1A8 File Offset: 0x002383A8
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 633642, XrefRangeEnd = 633659, 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: 0x06008B13 RID: 35603 RVA: 0x0023A234 File Offset: 0x00238434
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 633659, XrefRangeEnd = 633668, 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: 0x06008B14 RID: 35604 RVA: 0x0023A29C File Offset: 0x0023849C
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 633674, RefRangeEnd = 633676, XrefRangeStart = 633668, XrefRangeEnd = 633674, 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: 0x06008B15 RID: 35605 RVA: 0x0023A31C File Offset: 0x0023851C
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 633698, RefRangeEnd = 633700, XrefRangeStart = 633676, XrefRangeEnd = 633698, 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: 0x06008B16 RID: 35606 RVA: 0x0023A39C File Offset: 0x0023859C
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 633709, RefRangeEnd = 633711, XrefRangeStart = 633700, XrefRangeEnd = 633709, 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: 0x06008B17 RID: 35607 RVA: 0x0023A3F8 File Offset: 0x002385F8
		[CallerCount(3)]
		[CachedScanResults(RefRangeStart = 633718, RefRangeEnd = 633721, XrefRangeStart = 633711, XrefRangeEnd = 633718, 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: 0x06008B18 RID: 35608 RVA: 0x0023A43C File Offset: 0x0023863C
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 633721, XrefRangeEnd = 633723, 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: 0x06008B19 RID: 35609 RVA: 0x0023A48C File Offset: 0x0023868C
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 633723, XrefRangeEnd = 633728, 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: 0x06008B1A RID: 35610 RVA: 0x0023A4DC File Offset: 0x002386DC
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 633740, RefRangeEnd = 633741, XrefRangeStart = 633728, XrefRangeEnd = 633740, 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: 0x06008B1B RID: 35611 RVA: 0x0023A520 File Offset: 0x00238720
		[CallerCount(3)]
		[CachedScanResults(RefRangeStart = 633774, RefRangeEnd = 633777, XrefRangeStart = 633741, XrefRangeEnd = 633774, 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: 0x06008B1C RID: 35612 RVA: 0x0023A5E0 File Offset: 0x002387E0
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 633845, RefRangeEnd = 633846, XrefRangeStart = 633777, XrefRangeEnd = 633845, 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: 0x06008B1D RID: 35613 RVA: 0x0023A624 File Offset: 0x00238824
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 633852, RefRangeEnd = 633853, XrefRangeStart = 633846, XrefRangeEnd = 633852, 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: 0x06008B1E RID: 35614 RVA: 0x0023A688 File Offset: 0x00238888
		[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: 0x17002F35 RID: 12085
		// (get) Token: 0x06008B1F RID: 35615 RVA: 0x0023A6EC File Offset: 0x002388EC
		// (set) Token: 0x06008B20 RID: 35616 RVA: 0x0023A744 File Offset: 0x00238944
		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: 0x06008B21 RID: 35617 RVA: 0x0023A7A0 File Offset: 0x002389A0
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 633855, RefRangeEnd = 633857, XrefRangeStart = 633853, XrefRangeEnd = 633855, 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: 0x06008B22 RID: 35618 RVA: 0x0023A7E4 File Offset: 0x002389E4
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 633892, RefRangeEnd = 633893, XrefRangeStart = 633857, XrefRangeEnd = 633892, 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: 0x06008B23 RID: 35619 RVA: 0x0023A834 File Offset: 0x00238A34
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 633951, RefRangeEnd = 633952, XrefRangeStart = 633893, XrefRangeEnd = 633951, 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: 0x06008B24 RID: 35620 RVA: 0x0023A880 File Offset: 0x00238A80
		// 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, 100673960);
			IKSolverVR.NativeMethodInfoPtr_GuessHandOrientations_Public_Void_References_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673961);
			IKSolverVR.NativeMethodInfoPtr_DefaultAnimationCurves_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673962);
			IKSolverVR.NativeMethodInfoPtr_AddPositionOffset_Public_Void_PositionOffset_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673963);
			IKSolverVR.NativeMethodInfoPtr_AddRotationOffset_Public_Void_RotationOffset_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673964);
			IKSolverVR.NativeMethodInfoPtr_AddRotationOffset_Public_Void_RotationOffset_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673965);
			IKSolverVR.NativeMethodInfoPtr_AddPlatformMotion_Public_Void_Vector3_Quaternion_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673966);
			IKSolverVR.NativeMethodInfoPtr_Reset_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673967);
			IKSolverVR.NativeMethodInfoPtr_StoreDefaultLocalState_Public_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673968);
			IKSolverVR.NativeMethodInfoPtr_FixTransforms_Public_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673969);
			IKSolverVR.NativeMethodInfoPtr_GetPoints_Public_Virtual_Il2CppReferenceArray_1_Point_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673970);
			IKSolverVR.NativeMethodInfoPtr_GetPoint_Public_Virtual_Point_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673971);
			IKSolverVR.NativeMethodInfoPtr_IsValid_Public_Virtual_Boolean_byref_String_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673972);
			IKSolverVR.NativeMethodInfoPtr_GetNormal_Private_Vector3_Il2CppReferenceArray_1_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673973);
			IKSolverVR.NativeMethodInfoPtr_GuessWristToPalmAxis_Private_Vector3_Transform_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673974);
			IKSolverVR.NativeMethodInfoPtr_GuessPalmToThumbAxis_Private_Vector3_Transform_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673975);
			IKSolverVR.NativeMethodInfoPtr_GetSineKeyframes_Private_Static_Il2CppStructArray_1_Keyframe_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673976);
			IKSolverVR.NativeMethodInfoPtr_UpdateSolverTransforms_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673977);
			IKSolverVR.NativeMethodInfoPtr_OnInitiate_Protected_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673978);
			IKSolverVR.NativeMethodInfoPtr_OnUpdate_Protected_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673979);
			IKSolverVR.NativeMethodInfoPtr_WriteTransforms_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673980);
			IKSolverVR.NativeMethodInfoPtr_Read_Private_Void_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Quaternion_Boolean_Boolean_Boolean_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673981);
			IKSolverVR.NativeMethodInfoPtr_Solve_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673982);
			IKSolverVR.NativeMethodInfoPtr_GetPosition_Private_Vector3_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673983);
			IKSolverVR.NativeMethodInfoPtr_GetRotation_Private_Quaternion_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673984);
			IKSolverVR.NativeMethodInfoPtr_get_rootBone_Public_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673985);
			IKSolverVR.NativeMethodInfoPtr_set_rootBone_Private_set_Void_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673986);
			IKSolverVR.NativeMethodInfoPtr_Write_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673987);
			IKSolverVR.NativeMethodInfoPtr_GetPelvisOffset_Private_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673988);
			IKSolverVR.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR>.NativeClassPtr, 100673989);
		}

		// Token: 0x06008B25 RID: 35621 RVA: 0x00232E00 File Offset: 0x00231000
		public IKSolverVR(IntPtr pointer)
			: base(pointer)
		{
		}

		// Token: 0x17002F14 RID: 12052
		// (get) Token: 0x06008B26 RID: 35622 RVA: 0x0023AD9C File Offset: 0x00238F9C
		// (set) Token: 0x06008B27 RID: 35623 RVA: 0x0023ADD0 File Offset: 0x00238FD0
		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: 0x17002F15 RID: 12053
		// (get) Token: 0x06008B28 RID: 35624 RVA: 0x0023ADF8 File Offset: 0x00238FF8
		// (set) Token: 0x06008B29 RID: 35625 RVA: 0x0023AE20 File Offset: 0x00239020
		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: 0x17002F16 RID: 12054
		// (get) Token: 0x06008B2A RID: 35626 RVA: 0x0023AE44 File Offset: 0x00239044
		// (set) Token: 0x06008B2B RID: 35627 RVA: 0x0023AE6C File Offset: 0x0023906C
		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: 0x17002F17 RID: 12055
		// (get) Token: 0x06008B2C RID: 35628 RVA: 0x0023AE90 File Offset: 0x00239090
		// (set) Token: 0x06008B2D RID: 35629 RVA: 0x0023AEB8 File Offset: 0x002390B8
		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: 0x17002F18 RID: 12056
		// (get) Token: 0x06008B2E RID: 35630 RVA: 0x0023AEDC File Offset: 0x002390DC
		// (set) Token: 0x06008B2F RID: 35631 RVA: 0x0023AF04 File Offset: 0x00239104
		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: 0x17002F19 RID: 12057
		// (get) Token: 0x06008B30 RID: 35632 RVA: 0x0023AF28 File Offset: 0x00239128
		// (set) Token: 0x06008B31 RID: 35633 RVA: 0x0023AF5C File Offset: 0x0023915C
		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: 0x17002F1A RID: 12058
		// (get) Token: 0x06008B32 RID: 35634 RVA: 0x0023AF84 File Offset: 0x00239184
		// (set) Token: 0x06008B33 RID: 35635 RVA: 0x0023AFB8 File Offset: 0x002391B8
		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: 0x17002F1B RID: 12059
		// (get) Token: 0x06008B34 RID: 35636 RVA: 0x0023AFE0 File Offset: 0x002391E0
		// (set) Token: 0x06008B35 RID: 35637 RVA: 0x0023B014 File Offset: 0x00239214
		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: 0x17002F1C RID: 12060
		// (get) Token: 0x06008B36 RID: 35638 RVA: 0x0023B03C File Offset: 0x0023923C
		// (set) Token: 0x06008B37 RID: 35639 RVA: 0x0023B070 File Offset: 0x00239270
		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: 0x17002F1D RID: 12061
		// (get) Token: 0x06008B38 RID: 35640 RVA: 0x0023B098 File Offset: 0x00239298
		// (set) Token: 0x06008B39 RID: 35641 RVA: 0x0023B0C0 File Offset: 0x002392C0
		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: 0x17002F1E RID: 12062
		// (get) Token: 0x06008B3A RID: 35642 RVA: 0x0023B0E4 File Offset: 0x002392E4
		// (set) Token: 0x06008B3B RID: 35643 RVA: 0x0023B118 File Offset: 0x00239318
		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: 0x17002F1F RID: 12063
		// (get) Token: 0x06008B3C RID: 35644 RVA: 0x0023B140 File Offset: 0x00239340
		// (set) Token: 0x06008B3D RID: 35645 RVA: 0x0023B168 File Offset: 0x00239368
		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: 0x17002F20 RID: 12064
		// (get) Token: 0x06008B3E RID: 35646 RVA: 0x0023B18C File Offset: 0x0023938C
		// (set) Token: 0x06008B3F RID: 35647 RVA: 0x0023B1B4 File Offset: 0x002393B4
		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: 0x17002F21 RID: 12065
		// (get) Token: 0x06008B40 RID: 35648 RVA: 0x0023B1D8 File Offset: 0x002393D8
		// (set) Token: 0x06008B41 RID: 35649 RVA: 0x0023B200 File Offset: 0x00239400
		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: 0x17002F22 RID: 12066
		// (get) Token: 0x06008B42 RID: 35650 RVA: 0x0023B224 File Offset: 0x00239424
		// (set) Token: 0x06008B43 RID: 35651 RVA: 0x0023B24C File Offset: 0x0023944C
		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: 0x17002F23 RID: 12067
		// (get) Token: 0x06008B44 RID: 35652 RVA: 0x0023B270 File Offset: 0x00239470
		// (set) Token: 0x06008B45 RID: 35653 RVA: 0x0023B298 File Offset: 0x00239498
		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: 0x17002F24 RID: 12068
		// (get) Token: 0x06008B46 RID: 35654 RVA: 0x0023B2BC File Offset: 0x002394BC
		// (set) Token: 0x06008B47 RID: 35655 RVA: 0x0023B2F0 File Offset: 0x002394F0
		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: 0x17002F25 RID: 12069
		// (get) Token: 0x06008B48 RID: 35656 RVA: 0x0023B318 File Offset: 0x00239518
		// (set) Token: 0x06008B49 RID: 35657 RVA: 0x0023B34C File Offset: 0x0023954C
		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: 0x17002F26 RID: 12070
		// (get) Token: 0x06008B4A RID: 35658 RVA: 0x0023B374 File Offset: 0x00239574
		// (set) Token: 0x06008B4B RID: 35659 RVA: 0x0023B3A8 File Offset: 0x002395A8
		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: 0x17002F27 RID: 12071
		// (get) Token: 0x06008B4C RID: 35660 RVA: 0x0023B3D0 File Offset: 0x002395D0
		// (set) Token: 0x06008B4D RID: 35661 RVA: 0x0023B404 File Offset: 0x00239604
		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: 0x17002F28 RID: 12072
		// (get) Token: 0x06008B4E RID: 35662 RVA: 0x0023B42C File Offset: 0x0023962C
		// (set) Token: 0x06008B4F RID: 35663 RVA: 0x0023B460 File Offset: 0x00239660
		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: 0x17002F29 RID: 12073
		// (get) Token: 0x06008B50 RID: 35664 RVA: 0x0023B488 File Offset: 0x00239688
		// (set) Token: 0x06008B51 RID: 35665 RVA: 0x0023B4BC File Offset: 0x002396BC
		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: 0x17002F2A RID: 12074
		// (get) Token: 0x06008B52 RID: 35666 RVA: 0x0023B4E4 File Offset: 0x002396E4
		// (set) Token: 0x06008B53 RID: 35667 RVA: 0x0023B518 File Offset: 0x00239718
		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: 0x17002F2B RID: 12075
		// (get) Token: 0x06008B54 RID: 35668 RVA: 0x0023B540 File Offset: 0x00239740
		// (set) Token: 0x06008B55 RID: 35669 RVA: 0x0023B574 File Offset: 0x00239774
		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: 0x17002F2C RID: 12076
		// (get) Token: 0x06008B56 RID: 35670 RVA: 0x0023B59C File Offset: 0x0023979C
		// (set) Token: 0x06008B57 RID: 35671 RVA: 0x0023B5D0 File Offset: 0x002397D0
		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: 0x17002F2D RID: 12077
		// (get) Token: 0x06008B58 RID: 35672 RVA: 0x0023B5F8 File Offset: 0x002397F8
		// (set) Token: 0x06008B59 RID: 35673 RVA: 0x0023B620 File Offset: 0x00239820
		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: 0x17002F2E RID: 12078
		// (get) Token: 0x06008B5A RID: 35674 RVA: 0x0023B644 File Offset: 0x00239844
		// (set) Token: 0x06008B5B RID: 35675 RVA: 0x0023B66C File Offset: 0x0023986C
		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: 0x17002F2F RID: 12079
		// (get) Token: 0x06008B5C RID: 35676 RVA: 0x0023B690 File Offset: 0x00239890
		// (set) Token: 0x06008B5D RID: 35677 RVA: 0x0023B6B8 File Offset: 0x002398B8
		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: 0x17002F30 RID: 12080
		// (get) Token: 0x06008B5E RID: 35678 RVA: 0x0023B6DC File Offset: 0x002398DC
		// (set) Token: 0x06008B5F RID: 35679 RVA: 0x0023B704 File Offset: 0x00239904
		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: 0x17002F31 RID: 12081
		// (get) Token: 0x06008B60 RID: 35680 RVA: 0x0023B728 File Offset: 0x00239928
		// (set) Token: 0x06008B61 RID: 35681 RVA: 0x0023B750 File Offset: 0x00239950
		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: 0x17002F32 RID: 12082
		// (get) Token: 0x06008B62 RID: 35682 RVA: 0x0023B774 File Offset: 0x00239974
		// (set) Token: 0x06008B63 RID: 35683 RVA: 0x0023B79C File Offset: 0x0023999C
		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: 0x17002F33 RID: 12083
		// (get) Token: 0x06008B64 RID: 35684 RVA: 0x0023B7C0 File Offset: 0x002399C0
		// (set) Token: 0x06008B65 RID: 35685 RVA: 0x0023B7E8 File Offset: 0x002399E8
		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: 0x17002F34 RID: 12084
		// (get) Token: 0x06008B66 RID: 35686 RVA: 0x0023B80C File Offset: 0x00239A0C
		// (set) Token: 0x06008B67 RID: 35687 RVA: 0x0023B834 File Offset: 0x00239A34
		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: 0x04005D04 RID: 23812
		private static readonly IntPtr NativeFieldInfoPtr_solverTransforms;

		// Token: 0x04005D05 RID: 23813
		private static readonly IntPtr NativeFieldInfoPtr_hasChest;

		// Token: 0x04005D06 RID: 23814
		private static readonly IntPtr NativeFieldInfoPtr_hasNeck;

		// Token: 0x04005D07 RID: 23815
		private static readonly IntPtr NativeFieldInfoPtr_hasShoulders;

		// Token: 0x04005D08 RID: 23816
		private static readonly IntPtr NativeFieldInfoPtr_hasToes;

		// Token: 0x04005D09 RID: 23817
		private static readonly IntPtr NativeFieldInfoPtr_readPositions;

		// Token: 0x04005D0A RID: 23818
		private static readonly IntPtr NativeFieldInfoPtr_readRotations;

		// Token: 0x04005D0B RID: 23819
		private static readonly IntPtr NativeFieldInfoPtr_solvedPositions;

		// Token: 0x04005D0C RID: 23820
		private static readonly IntPtr NativeFieldInfoPtr_solvedRotations;

		// Token: 0x04005D0D RID: 23821
		private static readonly IntPtr NativeFieldInfoPtr_defaultPelvisLocalPosition;

		// Token: 0x04005D0E RID: 23822
		private static readonly IntPtr NativeFieldInfoPtr_defaultLocalRotations;

		// Token: 0x04005D0F RID: 23823
		private static readonly IntPtr NativeFieldInfoPtr_rootV;

		// Token: 0x04005D10 RID: 23824
		private static readonly IntPtr NativeFieldInfoPtr_rootVelocity;

		// Token: 0x04005D11 RID: 23825
		private static readonly IntPtr NativeFieldInfoPtr_bodyOffset;

		// Token: 0x04005D12 RID: 23826
		private static readonly IntPtr NativeFieldInfoPtr_supportLegIndex;

		// Token: 0x04005D13 RID: 23827
		private static readonly IntPtr NativeFieldInfoPtr_plantFeet;

		// Token: 0x04005D14 RID: 23828
		private static readonly IntPtr NativeFieldInfoPtr__rootBone_k__BackingField;

		// Token: 0x04005D15 RID: 23829
		private static readonly IntPtr NativeFieldInfoPtr_spine;

		// Token: 0x04005D16 RID: 23830
		private static readonly IntPtr NativeFieldInfoPtr_leftArm;

		// Token: 0x04005D17 RID: 23831
		private static readonly IntPtr NativeFieldInfoPtr_rightArm;

		// Token: 0x04005D18 RID: 23832
		private static readonly IntPtr NativeFieldInfoPtr_leftLeg;

		// Token: 0x04005D19 RID: 23833
		private static readonly IntPtr NativeFieldInfoPtr_rightLeg;

		// Token: 0x04005D1A RID: 23834
		private static readonly IntPtr NativeFieldInfoPtr_locomotion;

		// Token: 0x04005D1B RID: 23835
		private static readonly IntPtr NativeFieldInfoPtr_legs;

		// Token: 0x04005D1C RID: 23836
		private static readonly IntPtr NativeFieldInfoPtr_arms;

		// Token: 0x04005D1D RID: 23837
		private static readonly IntPtr NativeFieldInfoPtr_headPosition;

		// Token: 0x04005D1E RID: 23838
		private static readonly IntPtr NativeFieldInfoPtr_headDeltaPosition;

		// Token: 0x04005D1F RID: 23839
		private static readonly IntPtr NativeFieldInfoPtr_raycastOriginPelvis;

		// Token: 0x04005D20 RID: 23840
		private static readonly IntPtr NativeFieldInfoPtr_lastOffset;

		// Token: 0x04005D21 RID: 23841
		private static readonly IntPtr NativeFieldInfoPtr_debugPos1;

		// Token: 0x04005D22 RID: 23842
		private static readonly IntPtr NativeFieldInfoPtr_debugPos2;

		// Token: 0x04005D23 RID: 23843
		private static readonly IntPtr NativeFieldInfoPtr_debugPos3;

		// Token: 0x04005D24 RID: 23844
		private static readonly IntPtr NativeFieldInfoPtr_debugPos4;

		// Token: 0x04005D25 RID: 23845
		private static readonly IntPtr NativeMethodInfoPtr_SetToReferences_Public_Void_References_0;

		// Token: 0x04005D26 RID: 23846
		private static readonly IntPtr NativeMethodInfoPtr_GuessHandOrientations_Public_Void_References_Boolean_0;

		// Token: 0x04005D27 RID: 23847
		private static readonly IntPtr NativeMethodInfoPtr_DefaultAnimationCurves_Public_Void_0;

		// Token: 0x04005D28 RID: 23848
		private static readonly IntPtr NativeMethodInfoPtr_AddPositionOffset_Public_Void_PositionOffset_Vector3_0;

		// Token: 0x04005D29 RID: 23849
		private static readonly IntPtr NativeMethodInfoPtr_AddRotationOffset_Public_Void_RotationOffset_Vector3_0;

		// Token: 0x04005D2A RID: 23850
		private static readonly IntPtr NativeMethodInfoPtr_AddRotationOffset_Public_Void_RotationOffset_Quaternion_0;

		// Token: 0x04005D2B RID: 23851
		private static readonly IntPtr NativeMethodInfoPtr_AddPlatformMotion_Public_Void_Vector3_Quaternion_Vector3_0;

		// Token: 0x04005D2C RID: 23852
		private static readonly IntPtr NativeMethodInfoPtr_Reset_Public_Void_0;

		// Token: 0x04005D2D RID: 23853
		private static readonly IntPtr NativeMethodInfoPtr_StoreDefaultLocalState_Public_Virtual_Void_0;

		// Token: 0x04005D2E RID: 23854
		private static readonly IntPtr NativeMethodInfoPtr_FixTransforms_Public_Virtual_Void_0;

		// Token: 0x04005D2F RID: 23855
		private static readonly IntPtr NativeMethodInfoPtr_GetPoints_Public_Virtual_Il2CppReferenceArray_1_Point_0;

		// Token: 0x04005D30 RID: 23856
		private static readonly IntPtr NativeMethodInfoPtr_GetPoint_Public_Virtual_Point_Transform_0;

		// Token: 0x04005D31 RID: 23857
		private static readonly IntPtr NativeMethodInfoPtr_IsValid_Public_Virtual_Boolean_byref_String_0;

		// Token: 0x04005D32 RID: 23858
		private static readonly IntPtr NativeMethodInfoPtr_GetNormal_Private_Vector3_Il2CppReferenceArray_1_Transform_0;

		// Token: 0x04005D33 RID: 23859
		private static readonly IntPtr NativeMethodInfoPtr_GuessWristToPalmAxis_Private_Vector3_Transform_Transform_0;

		// Token: 0x04005D34 RID: 23860
		private static readonly IntPtr NativeMethodInfoPtr_GuessPalmToThumbAxis_Private_Vector3_Transform_Transform_0;

		// Token: 0x04005D35 RID: 23861
		private static readonly IntPtr NativeMethodInfoPtr_GetSineKeyframes_Private_Static_Il2CppStructArray_1_Keyframe_Single_0;

		// Token: 0x04005D36 RID: 23862
		private static readonly IntPtr NativeMethodInfoPtr_UpdateSolverTransforms_Private_Void_0;

		// Token: 0x04005D37 RID: 23863
		private static readonly IntPtr NativeMethodInfoPtr_OnInitiate_Protected_Virtual_Void_0;

		// Token: 0x04005D38 RID: 23864
		private static readonly IntPtr NativeMethodInfoPtr_OnUpdate_Protected_Virtual_Void_0;

		// Token: 0x04005D39 RID: 23865
		private static readonly IntPtr NativeMethodInfoPtr_WriteTransforms_Private_Void_0;

		// Token: 0x04005D3A RID: 23866
		private static readonly IntPtr NativeMethodInfoPtr_Read_Private_Void_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Quaternion_Boolean_Boolean_Boolean_Boolean_0;

		// Token: 0x04005D3B RID: 23867
		private static readonly IntPtr NativeMethodInfoPtr_Solve_Private_Void_0;

		// Token: 0x04005D3C RID: 23868
		private static readonly IntPtr NativeMethodInfoPtr_GetPosition_Private_Vector3_Int32_0;

		// Token: 0x04005D3D RID: 23869
		private static readonly IntPtr NativeMethodInfoPtr_GetRotation_Private_Quaternion_Int32_0;

		// Token: 0x04005D3E RID: 23870
		private static readonly IntPtr NativeMethodInfoPtr_get_rootBone_Public_get_VirtualBone_0;

		// Token: 0x04005D3F RID: 23871
		private static readonly IntPtr NativeMethodInfoPtr_set_rootBone_Private_set_Void_VirtualBone_0;

		// Token: 0x04005D40 RID: 23872
		private static readonly IntPtr NativeMethodInfoPtr_Write_Private_Void_0;

		// Token: 0x04005D41 RID: 23873
		private static readonly IntPtr NativeMethodInfoPtr_GetPelvisOffset_Private_Vector3_0;

		// Token: 0x04005D42 RID: 23874
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

		// Token: 0x020004A1 RID: 1185
		[Serializable]
		public class Arm : IKSolverVR.BodyPart
		{
			// Token: 0x17002F4F RID: 12111
			// (get) Token: 0x06008B68 RID: 35688 RVA: 0x0023B858 File Offset: 0x00239A58
			// (set) Token: 0x06008B69 RID: 35689 RVA: 0x0023B8A8 File Offset: 0x00239AA8
			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: 0x17002F50 RID: 12112
			// (get) Token: 0x06008B6A RID: 35690 RVA: 0x0023B8FC File Offset: 0x00239AFC
			// (set) Token: 0x06008B6B RID: 35691 RVA: 0x0023B94C File Offset: 0x00239B4C
			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: 0x17002F51 RID: 12113
			// (get) Token: 0x06008B6C RID: 35692 RVA: 0x0023B9A0 File Offset: 0x00239BA0
			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: 0x17002F52 RID: 12114
			// (get) Token: 0x06008B6D RID: 35693 RVA: 0x0023B9F8 File Offset: 0x00239BF8
			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: 0x17002F53 RID: 12115
			// (get) Token: 0x06008B6E RID: 35694 RVA: 0x0023BA50 File Offset: 0x00239C50
			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: 0x17002F54 RID: 12116
			// (get) Token: 0x06008B6F RID: 35695 RVA: 0x0023BAA8 File Offset: 0x00239CA8
			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: 0x06008B70 RID: 35696 RVA: 0x0023BB00 File Offset: 0x00239D00
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 632600, XrefRangeEnd = 632648, 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: 0x06008B71 RID: 35697 RVA: 0x0023BBF0 File Offset: 0x00239DF0
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 632648, XrefRangeEnd = 632659, 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: 0x06008B72 RID: 35698 RVA: 0x0023BC40 File Offset: 0x00239E40
			[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: 0x06008B73 RID: 35699 RVA: 0x0023BC90 File Offset: 0x00239E90
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 632754, RefRangeEnd = 632755, XrefRangeStart = 632659, XrefRangeEnd = 632754, 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: 0x06008B74 RID: 35700 RVA: 0x0023BCE4 File Offset: 0x00239EE4
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 632755, XrefRangeEnd = 632756, 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: 0x06008B75 RID: 35701 RVA: 0x0023BD34 File Offset: 0x00239F34
			[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: 0x06008B76 RID: 35702 RVA: 0x0023BDB4 File Offset: 0x00239FB4
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 632756, XrefRangeEnd = 632759, 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: 0x06008B77 RID: 35703 RVA: 0x0023BE50 File Offset: 0x0023A050
			[CallerCount(3)]
			[CachedScanResults(RefRangeStart = 632788, RefRangeEnd = 632791, XrefRangeStart = 632759, XrefRangeEnd = 632788, 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: 0x06008B78 RID: 35704 RVA: 0x0023BEB4 File Offset: 0x0023A0B4
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 632791, XrefRangeEnd = 632796, 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: 0x06008B79 RID: 35705 RVA: 0x0023BF50 File Offset: 0x0023A150
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 632808, RefRangeEnd = 632810, XrefRangeStart = 632796, XrefRangeEnd = 632808, 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: 0x06008B7A RID: 35706 RVA: 0x0023BF9C File Offset: 0x0023A19C
			// 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, 100673990);
				IKSolverVR.Arm.NativeMethodInfoPtr_set_position_Private_set_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100673991);
				IKSolverVR.Arm.NativeMethodInfoPtr_get_rotation_Public_get_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100673992);
				IKSolverVR.Arm.NativeMethodInfoPtr_set_rotation_Private_set_Void_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100673993);
				IKSolverVR.Arm.NativeMethodInfoPtr_get_shoulder_Private_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100673994);
				IKSolverVR.Arm.NativeMethodInfoPtr_get_upperArm_Private_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100673995);
				IKSolverVR.Arm.NativeMethodInfoPtr_get_forearm_Private_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100673996);
				IKSolverVR.Arm.NativeMethodInfoPtr_get_hand_Private_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100673997);
				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, 100673998);
				IKSolverVR.Arm.NativeMethodInfoPtr_PreSolve_Public_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100673999);
				IKSolverVR.Arm.NativeMethodInfoPtr_ApplyOffsets_Public_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100674000);
				IKSolverVR.Arm.NativeMethodInfoPtr_Solve_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100674001);
				IKSolverVR.Arm.NativeMethodInfoPtr_ResetOffsets_Public_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100674002);
				IKSolverVR.Arm.NativeMethodInfoPtr_Write_Public_Virtual_Void_byref_Il2CppStructArray_1_Vector3_byref_Il2CppStructArray_1_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100674003);
				IKSolverVR.Arm.NativeMethodInfoPtr_DamperValue_Private_Single_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100674004);
				IKSolverVR.Arm.NativeMethodInfoPtr_GetBendNormal_Private_Vector3_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100674005);
				IKSolverVR.Arm.NativeMethodInfoPtr_Visualize_Private_Void_VirtualBone_VirtualBone_VirtualBone_Color_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100674006);
				IKSolverVR.Arm.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Arm>.NativeClassPtr, 100674007);
			}

			// Token: 0x06008B7B RID: 35707 RVA: 0x0023C323 File Offset: 0x0023A523
			public Arm(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002F36 RID: 12086
			// (get) Token: 0x06008B7C RID: 35708 RVA: 0x0023C32C File Offset: 0x0023A52C
			// (set) Token: 0x06008B7D RID: 35709 RVA: 0x0023C360 File Offset: 0x0023A560
			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: 0x17002F37 RID: 12087
			// (get) Token: 0x06008B7E RID: 35710 RVA: 0x0023C388 File Offset: 0x0023A588
			// (set) Token: 0x06008B7F RID: 35711 RVA: 0x0023C3BC File Offset: 0x0023A5BC
			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: 0x17002F38 RID: 12088
			// (get) Token: 0x06008B80 RID: 35712 RVA: 0x0023C3E4 File Offset: 0x0023A5E4
			// (set) Token: 0x06008B81 RID: 35713 RVA: 0x0023C40C File Offset: 0x0023A60C
			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: 0x17002F39 RID: 12089
			// (get) Token: 0x06008B82 RID: 35714 RVA: 0x0023C430 File Offset: 0x0023A630
			// (set) Token: 0x06008B83 RID: 35715 RVA: 0x0023C458 File Offset: 0x0023A658
			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: 0x17002F3A RID: 12090
			// (get) Token: 0x06008B84 RID: 35716 RVA: 0x0023C47C File Offset: 0x0023A67C
			// (set) Token: 0x06008B85 RID: 35717 RVA: 0x0023C4A4 File Offset: 0x0023A6A4
			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: 0x17002F3B RID: 12091
			// (get) Token: 0x06008B86 RID: 35718 RVA: 0x0023C4C8 File Offset: 0x0023A6C8
			// (set) Token: 0x06008B87 RID: 35719 RVA: 0x0023C4F0 File Offset: 0x0023A6F0
			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: 0x17002F3C RID: 12092
			// (get) Token: 0x06008B88 RID: 35720 RVA: 0x0023C514 File Offset: 0x0023A714
			// (set) Token: 0x06008B89 RID: 35721 RVA: 0x0023C53C File Offset: 0x0023A73C
			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: 0x17002F3D RID: 12093
			// (get) Token: 0x06008B8A RID: 35722 RVA: 0x0023C560 File Offset: 0x0023A760
			// (set) Token: 0x06008B8B RID: 35723 RVA: 0x0023C588 File Offset: 0x0023A788
			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: 0x17002F3E RID: 12094
			// (get) Token: 0x06008B8C RID: 35724 RVA: 0x0023C5AC File Offset: 0x0023A7AC
			// (set) Token: 0x06008B8D RID: 35725 RVA: 0x0023C5D4 File Offset: 0x0023A7D4
			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: 0x17002F3F RID: 12095
			// (get) Token: 0x06008B8E RID: 35726 RVA: 0x0023C5F8 File Offset: 0x0023A7F8
			// (set) Token: 0x06008B8F RID: 35727 RVA: 0x0023C620 File Offset: 0x0023A820
			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: 0x17002F40 RID: 12096
			// (get) Token: 0x06008B90 RID: 35728 RVA: 0x0023C644 File Offset: 0x0023A844
			// (set) Token: 0x06008B91 RID: 35729 RVA: 0x0023C66C File Offset: 0x0023A86C
			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: 0x17002F41 RID: 12097
			// (get) Token: 0x06008B92 RID: 35730 RVA: 0x0023C690 File Offset: 0x0023A890
			// (set) Token: 0x06008B93 RID: 35731 RVA: 0x0023C6B8 File Offset: 0x0023A8B8
			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: 0x17002F42 RID: 12098
			// (get) Token: 0x06008B94 RID: 35732 RVA: 0x0023C6DC File Offset: 0x0023A8DC
			// (set) Token: 0x06008B95 RID: 35733 RVA: 0x0023C704 File Offset: 0x0023A904
			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: 0x17002F43 RID: 12099
			// (get) Token: 0x06008B96 RID: 35734 RVA: 0x0023C728 File Offset: 0x0023A928
			// (set) Token: 0x06008B97 RID: 35735 RVA: 0x0023C750 File Offset: 0x0023A950
			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: 0x17002F44 RID: 12100
			// (get) Token: 0x06008B98 RID: 35736 RVA: 0x0023C774 File Offset: 0x0023A974
			// (set) Token: 0x06008B99 RID: 35737 RVA: 0x0023C79C File Offset: 0x0023A99C
			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: 0x17002F45 RID: 12101
			// (get) Token: 0x06008B9A RID: 35738 RVA: 0x0023C7C0 File Offset: 0x0023A9C0
			// (set) Token: 0x06008B9B RID: 35739 RVA: 0x0023C7E8 File Offset: 0x0023A9E8
			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: 0x17002F46 RID: 12102
			// (get) Token: 0x06008B9C RID: 35740 RVA: 0x0023C80C File Offset: 0x0023AA0C
			// (set) Token: 0x06008B9D RID: 35741 RVA: 0x0023C834 File Offset: 0x0023AA34
			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: 0x17002F47 RID: 12103
			// (get) Token: 0x06008B9E RID: 35742 RVA: 0x0023C858 File Offset: 0x0023AA58
			// (set) Token: 0x06008B9F RID: 35743 RVA: 0x0023C880 File Offset: 0x0023AA80
			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: 0x17002F48 RID: 12104
			// (get) Token: 0x06008BA0 RID: 35744 RVA: 0x0023C8A4 File Offset: 0x0023AAA4
			// (set) Token: 0x06008BA1 RID: 35745 RVA: 0x0023C8CC File Offset: 0x0023AACC
			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: 0x17002F49 RID: 12105
			// (get) Token: 0x06008BA2 RID: 35746 RVA: 0x0023C8F0 File Offset: 0x0023AAF0
			// (set) Token: 0x06008BA3 RID: 35747 RVA: 0x0023C918 File Offset: 0x0023AB18
			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: 0x17002F4A RID: 12106
			// (get) Token: 0x06008BA4 RID: 35748 RVA: 0x0023C93C File Offset: 0x0023AB3C
			// (set) Token: 0x06008BA5 RID: 35749 RVA: 0x0023C964 File Offset: 0x0023AB64
			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: 0x17002F4B RID: 12107
			// (get) Token: 0x06008BA6 RID: 35750 RVA: 0x0023C988 File Offset: 0x0023AB88
			// (set) Token: 0x06008BA7 RID: 35751 RVA: 0x0023C9B0 File Offset: 0x0023ABB0
			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: 0x17002F4C RID: 12108
			// (get) Token: 0x06008BA8 RID: 35752 RVA: 0x0023C9D4 File Offset: 0x0023ABD4
			// (set) Token: 0x06008BA9 RID: 35753 RVA: 0x0023C9FC File Offset: 0x0023ABFC
			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: 0x17002F4D RID: 12109
			// (get) Token: 0x06008BAA RID: 35754 RVA: 0x0023CA20 File Offset: 0x0023AC20
			// (set) Token: 0x06008BAB RID: 35755 RVA: 0x0023CA3E File Offset: 0x0023AC3E
			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: 0x17002F4E RID: 12110
			// (get) Token: 0x06008BAC RID: 35756 RVA: 0x0023CA50 File Offset: 0x0023AC50
			// (set) Token: 0x06008BAD RID: 35757 RVA: 0x0023CA6E File Offset: 0x0023AC6E
			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: 0x04005D43 RID: 23875
			private static readonly IntPtr NativeFieldInfoPtr_target;

			// Token: 0x04005D44 RID: 23876
			private static readonly IntPtr NativeFieldInfoPtr_bendGoal;

			// Token: 0x04005D45 RID: 23877
			private static readonly IntPtr NativeFieldInfoPtr_positionWeight;

			// Token: 0x04005D46 RID: 23878
			private static readonly IntPtr NativeFieldInfoPtr_rotationWeight;

			// Token: 0x04005D47 RID: 23879
			private static readonly IntPtr NativeFieldInfoPtr_shoulderRotationMode;

			// Token: 0x04005D48 RID: 23880
			private static readonly IntPtr NativeFieldInfoPtr_shoulderRotationWeight;

			// Token: 0x04005D49 RID: 23881
			private static readonly IntPtr NativeFieldInfoPtr_bendGoalWeight;

			// Token: 0x04005D4A RID: 23882
			private static readonly IntPtr NativeFieldInfoPtr_swivelOffset;

			// Token: 0x04005D4B RID: 23883
			private static readonly IntPtr NativeFieldInfoPtr_wristToPalmAxis;

			// Token: 0x04005D4C RID: 23884
			private static readonly IntPtr NativeFieldInfoPtr_palmToThumbAxis;

			// Token: 0x04005D4D RID: 23885
			private static readonly IntPtr NativeFieldInfoPtr_IKPosition;

			// Token: 0x04005D4E RID: 23886
			private static readonly IntPtr NativeFieldInfoPtr_IKRotation;

			// Token: 0x04005D4F RID: 23887
			private static readonly IntPtr NativeFieldInfoPtr_bendDirection;

			// Token: 0x04005D50 RID: 23888
			private static readonly IntPtr NativeFieldInfoPtr_handPositionOffset;

			// Token: 0x04005D51 RID: 23889
			private static readonly IntPtr NativeFieldInfoPtr__position_k__BackingField;

			// Token: 0x04005D52 RID: 23890
			private static readonly IntPtr NativeFieldInfoPtr__rotation_k__BackingField;

			// Token: 0x04005D53 RID: 23891
			private static readonly IntPtr NativeFieldInfoPtr_hasShoulder;

			// Token: 0x04005D54 RID: 23892
			private static readonly IntPtr NativeFieldInfoPtr_chestForwardAxis;

			// Token: 0x04005D55 RID: 23893
			private static readonly IntPtr NativeFieldInfoPtr_chestUpAxis;

			// Token: 0x04005D56 RID: 23894
			private static readonly IntPtr NativeFieldInfoPtr_chestRotation;

			// Token: 0x04005D57 RID: 23895
			private static readonly IntPtr NativeFieldInfoPtr_chestForward;

			// Token: 0x04005D58 RID: 23896
			private static readonly IntPtr NativeFieldInfoPtr_chestUp;

			// Token: 0x04005D59 RID: 23897
			private static readonly IntPtr NativeFieldInfoPtr_forearmRelToUpperArm;

			// Token: 0x04005D5A RID: 23898
			private static readonly IntPtr NativeFieldInfoPtr_yawOffsetAngle;

			// Token: 0x04005D5B RID: 23899
			private static readonly IntPtr NativeFieldInfoPtr_pitchOffsetAngle;

			// Token: 0x04005D5C RID: 23900
			private static readonly IntPtr NativeMethodInfoPtr_get_position_Public_get_Vector3_0;

			// Token: 0x04005D5D RID: 23901
			private static readonly IntPtr NativeMethodInfoPtr_set_position_Private_set_Void_Vector3_0;

			// Token: 0x04005D5E RID: 23902
			private static readonly IntPtr NativeMethodInfoPtr_get_rotation_Public_get_Quaternion_0;

			// Token: 0x04005D5F RID: 23903
			private static readonly IntPtr NativeMethodInfoPtr_set_rotation_Private_set_Void_Quaternion_0;

			// Token: 0x04005D60 RID: 23904
			private static readonly IntPtr NativeMethodInfoPtr_get_shoulder_Private_get_VirtualBone_0;

			// Token: 0x04005D61 RID: 23905
			private static readonly IntPtr NativeMethodInfoPtr_get_upperArm_Private_get_VirtualBone_0;

			// Token: 0x04005D62 RID: 23906
			private static readonly IntPtr NativeMethodInfoPtr_get_forearm_Private_get_VirtualBone_0;

			// Token: 0x04005D63 RID: 23907
			private static readonly IntPtr NativeMethodInfoPtr_get_hand_Private_get_VirtualBone_0;

			// Token: 0x04005D64 RID: 23908
			private static readonly IntPtr NativeMethodInfoPtr_OnRead_Protected_Virtual_Void_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Quaternion_Boolean_Boolean_Boolean_Boolean_Int32_Int32_0;

			// Token: 0x04005D65 RID: 23909
			private static readonly IntPtr NativeMethodInfoPtr_PreSolve_Public_Virtual_Void_0;

			// Token: 0x04005D66 RID: 23910
			private static readonly IntPtr NativeMethodInfoPtr_ApplyOffsets_Public_Virtual_Void_0;

			// Token: 0x04005D67 RID: 23911
			private static readonly IntPtr NativeMethodInfoPtr_Solve_Public_Void_Boolean_0;

			// Token: 0x04005D68 RID: 23912
			private static readonly IntPtr NativeMethodInfoPtr_ResetOffsets_Public_Virtual_Void_0;

			// Token: 0x04005D69 RID: 23913
			private static readonly IntPtr NativeMethodInfoPtr_Write_Public_Virtual_Void_byref_Il2CppStructArray_1_Vector3_byref_Il2CppStructArray_1_Quaternion_0;

			// Token: 0x04005D6A RID: 23914
			private static readonly IntPtr NativeMethodInfoPtr_DamperValue_Private_Single_Single_Single_Single_Single_0;

			// Token: 0x04005D6B RID: 23915
			private static readonly IntPtr NativeMethodInfoPtr_GetBendNormal_Private_Vector3_Vector3_0;

			// Token: 0x04005D6C RID: 23916
			private static readonly IntPtr NativeMethodInfoPtr_Visualize_Private_Void_VirtualBone_VirtualBone_VirtualBone_Color_0;

			// Token: 0x04005D6D RID: 23917
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

			// Token: 0x020004A2 RID: 1186
			[Serializable]
			public enum ShoulderRotationMode
			{
				// Token: 0x04005D6F RID: 23919
				YawPitch,
				// Token: 0x04005D70 RID: 23920
				FromTo
			}
		}

		// Token: 0x020004A3 RID: 1187
		[Serializable]
		public class BodyPart : Il2CppSystem.Object
		{
			// Token: 0x06008BAE RID: 35758 RVA: 0x0023CA80 File Offset: 0x0023AC80
			[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: 0x06008BAF RID: 35759 RVA: 0x0023CB70 File Offset: 0x0023AD70
			[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: 0x06008BB0 RID: 35760 RVA: 0x0023CBC0 File Offset: 0x0023ADC0
			[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: 0x06008BB1 RID: 35761 RVA: 0x0023CC40 File Offset: 0x0023AE40
			[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: 0x06008BB2 RID: 35762 RVA: 0x0023CC90 File Offset: 0x0023AE90
			[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: 0x17002F5C RID: 12124
			// (get) Token: 0x06008BB3 RID: 35763 RVA: 0x0023CCE0 File Offset: 0x0023AEE0
			// (set) Token: 0x06008BB4 RID: 35764 RVA: 0x0023CD30 File Offset: 0x0023AF30
			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: 0x17002F5D RID: 12125
			// (get) Token: 0x06008BB5 RID: 35765 RVA: 0x0023CD84 File Offset: 0x0023AF84
			// (set) Token: 0x06008BB6 RID: 35766 RVA: 0x0023CDD4 File Offset: 0x0023AFD4
			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: 0x06008BB7 RID: 35767 RVA: 0x0023CE28 File Offset: 0x0023B028
			[CallerCount(6)]
			[CachedScanResults(RefRangeStart = 632811, RefRangeEnd = 632817, XrefRangeStart = 632810, XrefRangeEnd = 632811, 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: 0x06008BB8 RID: 35768 RVA: 0x0023CF0C File Offset: 0x0023B10C
			[CallerCount(3)]
			[CachedScanResults(RefRangeStart = 632818, RefRangeEnd = 632821, XrefRangeStart = 632817, XrefRangeEnd = 632818, 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: 0x06008BB9 RID: 35769 RVA: 0x0023CF60 File Offset: 0x0023B160
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 632821, XrefRangeEnd = 632823, 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: 0x06008BBA RID: 35770 RVA: 0x0023CFB4 File Offset: 0x0023B1B4
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 632823, XrefRangeEnd = 632826, 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: 0x06008BBB RID: 35771 RVA: 0x0023D01C File Offset: 0x0023B21C
			[CallerCount(3)]
			[CachedScanResults(RefRangeStart = 632829, RefRangeEnd = 632832, XrefRangeStart = 632826, XrefRangeEnd = 632829, 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: 0x06008BBC RID: 35772 RVA: 0x0023D084 File Offset: 0x0023B284
			[CallerCount(3)]
			[CachedScanResults(RefRangeStart = 632837, RefRangeEnd = 632840, XrefRangeStart = 632832, XrefRangeEnd = 632837, 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: 0x06008BBD RID: 35773 RVA: 0x0023D104 File Offset: 0x0023B304
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 632840, XrefRangeEnd = 632845, 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: 0x06008BBE RID: 35774 RVA: 0x0023D158 File Offset: 0x0023B358
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 632845, XrefRangeEnd = 632851, 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: 0x06008BBF RID: 35775 RVA: 0x0023D19C File Offset: 0x0023B39C
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 632851, XrefRangeEnd = 632857, 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: 0x06008BC0 RID: 35776 RVA: 0x0023D1E8 File Offset: 0x0023B3E8
			// 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, 100674008);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_PreSolve_Public_Abstract_Virtual_New_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100674009);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_Write_Public_Abstract_Virtual_New_Void_byref_Il2CppStructArray_1_Vector3_byref_Il2CppStructArray_1_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100674010);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_ApplyOffsets_Public_Abstract_Virtual_New_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100674011);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_ResetOffsets_Public_Abstract_Virtual_New_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100674012);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_get_sqrMag_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100674013);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_set_sqrMag_Private_set_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100674014);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_get_mag_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100674015);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_set_mag_Private_set_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100674016);
				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, 100674017);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_MovePosition_Public_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100674018);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_MoveRotation_Public_Void_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100674019);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_Translate_Public_Void_Vector3_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100674020);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_TranslateRoot_Public_Void_Vector3_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100674021);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_RotateTo_Public_Void_VirtualBone_Quaternion_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100674022);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_Visualize_Public_Void_Color_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100674023);
				IKSolverVR.BodyPart.NativeMethodInfoPtr_Visualize_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100674024);
				IKSolverVR.BodyPart.NativeMethodInfoPtr__ctor_Protected_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.BodyPart>.NativeClassPtr, 100674025);
			}

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

			// Token: 0x17002F55 RID: 12117
			// (get) Token: 0x06008BC2 RID: 35778 RVA: 0x0023D408 File Offset: 0x0023B608
			// (set) Token: 0x06008BC3 RID: 35779 RVA: 0x0023D430 File Offset: 0x0023B630
			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: 0x17002F56 RID: 12118
			// (get) Token: 0x06008BC4 RID: 35780 RVA: 0x0023D454 File Offset: 0x0023B654
			// (set) Token: 0x06008BC5 RID: 35781 RVA: 0x0023D47C File Offset: 0x0023B67C
			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: 0x17002F57 RID: 12119
			// (get) Token: 0x06008BC6 RID: 35782 RVA: 0x0023D4A0 File Offset: 0x0023B6A0
			// (set) Token: 0x06008BC7 RID: 35783 RVA: 0x0023D4D4 File Offset: 0x0023B6D4
			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: 0x17002F58 RID: 12120
			// (get) Token: 0x06008BC8 RID: 35784 RVA: 0x0023D4FC File Offset: 0x0023B6FC
			// (set) Token: 0x06008BC9 RID: 35785 RVA: 0x0023D524 File Offset: 0x0023B724
			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: 0x17002F59 RID: 12121
			// (get) Token: 0x06008BCA RID: 35786 RVA: 0x0023D548 File Offset: 0x0023B748
			// (set) Token: 0x06008BCB RID: 35787 RVA: 0x0023D570 File Offset: 0x0023B770
			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: 0x17002F5A RID: 12122
			// (get) Token: 0x06008BCC RID: 35788 RVA: 0x0023D594 File Offset: 0x0023B794
			// (set) Token: 0x06008BCD RID: 35789 RVA: 0x0023D5BC File Offset: 0x0023B7BC
			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: 0x17002F5B RID: 12123
			// (get) Token: 0x06008BCE RID: 35790 RVA: 0x0023D5E0 File Offset: 0x0023B7E0
			// (set) Token: 0x06008BCF RID: 35791 RVA: 0x0023D608 File Offset: 0x0023B808
			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: 0x04005D71 RID: 23921
			private static readonly IntPtr NativeFieldInfoPtr__sqrMag_k__BackingField;

			// Token: 0x04005D72 RID: 23922
			private static readonly IntPtr NativeFieldInfoPtr__mag_k__BackingField;

			// Token: 0x04005D73 RID: 23923
			private static readonly IntPtr NativeFieldInfoPtr_bones;

			// Token: 0x04005D74 RID: 23924
			private static readonly IntPtr NativeFieldInfoPtr_initiated;

			// Token: 0x04005D75 RID: 23925
			private static readonly IntPtr NativeFieldInfoPtr_rootPosition;

			// Token: 0x04005D76 RID: 23926
			private static readonly IntPtr NativeFieldInfoPtr_rootRotation;

			// Token: 0x04005D77 RID: 23927
			private static readonly IntPtr NativeFieldInfoPtr_index;

			// Token: 0x04005D78 RID: 23928
			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: 0x04005D79 RID: 23929
			private static readonly IntPtr NativeMethodInfoPtr_PreSolve_Public_Abstract_Virtual_New_Void_0;

			// Token: 0x04005D7A RID: 23930
			private static readonly IntPtr NativeMethodInfoPtr_Write_Public_Abstract_Virtual_New_Void_byref_Il2CppStructArray_1_Vector3_byref_Il2CppStructArray_1_Quaternion_0;

			// Token: 0x04005D7B RID: 23931
			private static readonly IntPtr NativeMethodInfoPtr_ApplyOffsets_Public_Abstract_Virtual_New_Void_0;

			// Token: 0x04005D7C RID: 23932
			private static readonly IntPtr NativeMethodInfoPtr_ResetOffsets_Public_Abstract_Virtual_New_Void_0;

			// Token: 0x04005D7D RID: 23933
			private static readonly IntPtr NativeMethodInfoPtr_get_sqrMag_Public_get_Single_0;

			// Token: 0x04005D7E RID: 23934
			private static readonly IntPtr NativeMethodInfoPtr_set_sqrMag_Private_set_Void_Single_0;

			// Token: 0x04005D7F RID: 23935
			private static readonly IntPtr NativeMethodInfoPtr_get_mag_Public_get_Single_0;

			// Token: 0x04005D80 RID: 23936
			private static readonly IntPtr NativeMethodInfoPtr_set_mag_Private_set_Void_Single_0;

			// Token: 0x04005D81 RID: 23937
			private static readonly IntPtr NativeMethodInfoPtr_Read_Public_Void_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Quaternion_Boolean_Boolean_Boolean_Boolean_Int32_Int32_0;

			// Token: 0x04005D82 RID: 23938
			private static readonly IntPtr NativeMethodInfoPtr_MovePosition_Public_Void_Vector3_0;

			// Token: 0x04005D83 RID: 23939
			private static readonly IntPtr NativeMethodInfoPtr_MoveRotation_Public_Void_Quaternion_0;

			// Token: 0x04005D84 RID: 23940
			private static readonly IntPtr NativeMethodInfoPtr_Translate_Public_Void_Vector3_Quaternion_0;

			// Token: 0x04005D85 RID: 23941
			private static readonly IntPtr NativeMethodInfoPtr_TranslateRoot_Public_Void_Vector3_Quaternion_0;

			// Token: 0x04005D86 RID: 23942
			private static readonly IntPtr NativeMethodInfoPtr_RotateTo_Public_Void_VirtualBone_Quaternion_Single_0;

			// Token: 0x04005D87 RID: 23943
			private static readonly IntPtr NativeMethodInfoPtr_Visualize_Public_Void_Color_0;

			// Token: 0x04005D88 RID: 23944
			private static readonly IntPtr NativeMethodInfoPtr_Visualize_Public_Void_0;

			// Token: 0x04005D89 RID: 23945
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Protected_Void_0;
		}

		// Token: 0x020004A4 RID: 1188
		[Serializable]
		public class Footstep : Il2CppSystem.Object
		{
			// Token: 0x17002F6C RID: 12140
			// (get) Token: 0x06008BD0 RID: 35792 RVA: 0x0023D62C File Offset: 0x0023B82C
			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: 0x17002F6D RID: 12141
			// (get) Token: 0x06008BD1 RID: 35793 RVA: 0x0023D67C File Offset: 0x0023B87C
			// (set) Token: 0x06008BD2 RID: 35794 RVA: 0x0023D6CC File Offset: 0x0023B8CC
			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 = 225983, RefRangeEnd = 225985, XrefRangeStart = 225983, XrefRangeEnd = 225985, 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: 0x06008BD3 RID: 35795 RVA: 0x0023D720 File Offset: 0x0023B920
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 632857, XrefRangeEnd = 632865, 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: 0x06008BD4 RID: 35796 RVA: 0x0023D7B8 File Offset: 0x0023B9B8
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 632865, XrefRangeEnd = 632867, 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: 0x06008BD5 RID: 35797 RVA: 0x0023D834 File Offset: 0x0023BA34
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 632867, XrefRangeEnd = 632868, 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: 0x06008BD6 RID: 35798 RVA: 0x0023D89C File Offset: 0x0023BA9C
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 632875, RefRangeEnd = 632876, XrefRangeStart = 632868, XrefRangeEnd = 632875, 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: 0x06008BD7 RID: 35799 RVA: 0x0023D918 File Offset: 0x0023BB18
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 632884, RefRangeEnd = 632885, XrefRangeStart = 632876, XrefRangeEnd = 632884, 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: 0x06008BD8 RID: 35800 RVA: 0x0023D994 File Offset: 0x0023BB94
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 632893, RefRangeEnd = 632895, XrefRangeStart = 632885, XrefRangeEnd = 632893, 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: 0x06008BD9 RID: 35801 RVA: 0x0023DA00 File Offset: 0x0023BC00
			// 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, 100674026);
				IKSolverVR.Footstep.NativeMethodInfoPtr_get_stepProgress_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Footstep>.NativeClassPtr, 100674027);
				IKSolverVR.Footstep.NativeMethodInfoPtr_set_stepProgress_Private_set_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Footstep>.NativeClassPtr, 100674028);
				IKSolverVR.Footstep.NativeMethodInfoPtr__ctor_Public_Void_Quaternion_Vector3_Quaternion_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Footstep>.NativeClassPtr, 100674029);
				IKSolverVR.Footstep.NativeMethodInfoPtr_Reset_Public_Void_Quaternion_Vector3_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Footstep>.NativeClassPtr, 100674030);
				IKSolverVR.Footstep.NativeMethodInfoPtr_StepTo_Public_Void_Vector3_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Footstep>.NativeClassPtr, 100674031);
				IKSolverVR.Footstep.NativeMethodInfoPtr_UpdateStepping_Public_Void_Vector3_Quaternion_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Footstep>.NativeClassPtr, 100674032);
				IKSolverVR.Footstep.NativeMethodInfoPtr_UpdateStanding_Public_Void_Quaternion_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Footstep>.NativeClassPtr, 100674033);
				IKSolverVR.Footstep.NativeMethodInfoPtr_Update_Public_Void_InterpolationMode_UnityEvent_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Footstep>.NativeClassPtr, 100674034);
			}

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

			// Token: 0x17002F5E RID: 12126
			// (get) Token: 0x06008BDB RID: 35803 RVA: 0x0023DBF8 File Offset: 0x0023BDF8
			// (set) Token: 0x06008BDC RID: 35804 RVA: 0x0023DC20 File Offset: 0x0023BE20
			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: 0x17002F5F RID: 12127
			// (get) Token: 0x06008BDD RID: 35805 RVA: 0x0023DC44 File Offset: 0x0023BE44
			// (set) Token: 0x06008BDE RID: 35806 RVA: 0x0023DC6C File Offset: 0x0023BE6C
			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: 0x17002F60 RID: 12128
			// (get) Token: 0x06008BDF RID: 35807 RVA: 0x0023DC90 File Offset: 0x0023BE90
			// (set) Token: 0x06008BE0 RID: 35808 RVA: 0x0023DCB8 File Offset: 0x0023BEB8
			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: 0x17002F61 RID: 12129
			// (get) Token: 0x06008BE1 RID: 35809 RVA: 0x0023DCDC File Offset: 0x0023BEDC
			// (set) Token: 0x06008BE2 RID: 35810 RVA: 0x0023DD04 File Offset: 0x0023BF04
			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: 0x17002F62 RID: 12130
			// (get) Token: 0x06008BE3 RID: 35811 RVA: 0x0023DD28 File Offset: 0x0023BF28
			// (set) Token: 0x06008BE4 RID: 35812 RVA: 0x0023DD50 File Offset: 0x0023BF50
			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: 0x17002F63 RID: 12131
			// (get) Token: 0x06008BE5 RID: 35813 RVA: 0x0023DD74 File Offset: 0x0023BF74
			// (set) Token: 0x06008BE6 RID: 35814 RVA: 0x0023DD9C File Offset: 0x0023BF9C
			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: 0x17002F64 RID: 12132
			// (get) Token: 0x06008BE7 RID: 35815 RVA: 0x0023DDC0 File Offset: 0x0023BFC0
			// (set) Token: 0x06008BE8 RID: 35816 RVA: 0x0023DDE8 File Offset: 0x0023BFE8
			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: 0x17002F65 RID: 12133
			// (get) Token: 0x06008BE9 RID: 35817 RVA: 0x0023DE0C File Offset: 0x0023C00C
			// (set) Token: 0x06008BEA RID: 35818 RVA: 0x0023DE34 File Offset: 0x0023C034
			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: 0x17002F66 RID: 12134
			// (get) Token: 0x06008BEB RID: 35819 RVA: 0x0023DE58 File Offset: 0x0023C058
			// (set) Token: 0x06008BEC RID: 35820 RVA: 0x0023DE80 File Offset: 0x0023C080
			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: 0x17002F67 RID: 12135
			// (get) Token: 0x06008BED RID: 35821 RVA: 0x0023DEA4 File Offset: 0x0023C0A4
			// (set) Token: 0x06008BEE RID: 35822 RVA: 0x0023DECC File Offset: 0x0023C0CC
			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: 0x17002F68 RID: 12136
			// (get) Token: 0x06008BEF RID: 35823 RVA: 0x0023DEF0 File Offset: 0x0023C0F0
			// (set) Token: 0x06008BF0 RID: 35824 RVA: 0x0023DF18 File Offset: 0x0023C118
			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: 0x17002F69 RID: 12137
			// (get) Token: 0x06008BF1 RID: 35825 RVA: 0x0023DF3C File Offset: 0x0023C13C
			// (set) Token: 0x06008BF2 RID: 35826 RVA: 0x0023DF64 File Offset: 0x0023C164
			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: 0x17002F6A RID: 12138
			// (get) Token: 0x06008BF3 RID: 35827 RVA: 0x0023DF88 File Offset: 0x0023C188
			// (set) Token: 0x06008BF4 RID: 35828 RVA: 0x0023DFB0 File Offset: 0x0023C1B0
			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: 0x17002F6B RID: 12139
			// (get) Token: 0x06008BF5 RID: 35829 RVA: 0x0023DFD4 File Offset: 0x0023C1D4
			// (set) Token: 0x06008BF6 RID: 35830 RVA: 0x0023DFFC File Offset: 0x0023C1FC
			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: 0x04005D8A RID: 23946
			private static readonly IntPtr NativeFieldInfoPtr_stepSpeed;

			// Token: 0x04005D8B RID: 23947
			private static readonly IntPtr NativeFieldInfoPtr_characterSpaceOffset;

			// Token: 0x04005D8C RID: 23948
			private static readonly IntPtr NativeFieldInfoPtr_position;

			// Token: 0x04005D8D RID: 23949
			private static readonly IntPtr NativeFieldInfoPtr_rotation;

			// Token: 0x04005D8E RID: 23950
			private static readonly IntPtr NativeFieldInfoPtr_stepToRootRot;

			// Token: 0x04005D8F RID: 23951
			private static readonly IntPtr NativeFieldInfoPtr_isSupportLeg;

			// Token: 0x04005D90 RID: 23952
			private static readonly IntPtr NativeFieldInfoPtr__stepProgress_k__BackingField;

			// Token: 0x04005D91 RID: 23953
			private static readonly IntPtr NativeFieldInfoPtr_stepFrom;

			// Token: 0x04005D92 RID: 23954
			private static readonly IntPtr NativeFieldInfoPtr_stepTo;

			// Token: 0x04005D93 RID: 23955
			private static readonly IntPtr NativeFieldInfoPtr_stepFromRot;

			// Token: 0x04005D94 RID: 23956
			private static readonly IntPtr NativeFieldInfoPtr_stepToRot;

			// Token: 0x04005D95 RID: 23957
			private static readonly IntPtr NativeFieldInfoPtr_footRelativeToRoot;

			// Token: 0x04005D96 RID: 23958
			private static readonly IntPtr NativeFieldInfoPtr_supportLegW;

			// Token: 0x04005D97 RID: 23959
			private static readonly IntPtr NativeFieldInfoPtr_supportLegWV;

			// Token: 0x04005D98 RID: 23960
			private static readonly IntPtr NativeMethodInfoPtr_get_isStepping_Public_get_Boolean_0;

			// Token: 0x04005D99 RID: 23961
			private static readonly IntPtr NativeMethodInfoPtr_get_stepProgress_Public_get_Single_0;

			// Token: 0x04005D9A RID: 23962
			private static readonly IntPtr NativeMethodInfoPtr_set_stepProgress_Private_set_Void_Single_0;

			// Token: 0x04005D9B RID: 23963
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_Quaternion_Vector3_Quaternion_Vector3_0;

			// Token: 0x04005D9C RID: 23964
			private static readonly IntPtr NativeMethodInfoPtr_Reset_Public_Void_Quaternion_Vector3_Quaternion_0;

			// Token: 0x04005D9D RID: 23965
			private static readonly IntPtr NativeMethodInfoPtr_StepTo_Public_Void_Vector3_Quaternion_0;

			// Token: 0x04005D9E RID: 23966
			private static readonly IntPtr NativeMethodInfoPtr_UpdateStepping_Public_Void_Vector3_Quaternion_Single_0;

			// Token: 0x04005D9F RID: 23967
			private static readonly IntPtr NativeMethodInfoPtr_UpdateStanding_Public_Void_Quaternion_Single_Single_0;

			// Token: 0x04005DA0 RID: 23968
			private static readonly IntPtr NativeMethodInfoPtr_Update_Public_Void_InterpolationMode_UnityEvent_0;
		}

		// Token: 0x020004A5 RID: 1189
		[Serializable]
		public class Leg : IKSolverVR.BodyPart
		{
			// Token: 0x17002F82 RID: 12162
			// (get) Token: 0x06008BF7 RID: 35831 RVA: 0x0023E020 File Offset: 0x0023C220
			// (set) Token: 0x06008BF8 RID: 35832 RVA: 0x0023E070 File Offset: 0x0023C270
			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: 0x17002F83 RID: 12163
			// (get) Token: 0x06008BF9 RID: 35833 RVA: 0x0023E0C4 File Offset: 0x0023C2C4
			// (set) Token: 0x06008BFA RID: 35834 RVA: 0x0023E114 File Offset: 0x0023C314
			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: 0x17002F84 RID: 12164
			// (get) Token: 0x06008BFB RID: 35835 RVA: 0x0023E168 File Offset: 0x0023C368
			// (set) Token: 0x06008BFC RID: 35836 RVA: 0x0023E1B8 File Offset: 0x0023C3B8
			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: 0x17002F85 RID: 12165
			// (get) Token: 0x06008BFD RID: 35837 RVA: 0x0023E20C File Offset: 0x0023C40C
			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: 0x17002F86 RID: 12166
			// (get) Token: 0x06008BFE RID: 35838 RVA: 0x0023E264 File Offset: 0x0023C464
			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: 0x17002F87 RID: 12167
			// (get) Token: 0x06008BFF RID: 35839 RVA: 0x0023E2BC File Offset: 0x0023C4BC
			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: 0x17002F88 RID: 12168
			// (get) Token: 0x06008C00 RID: 35840 RVA: 0x0023E314 File Offset: 0x0023C514
			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: 0x17002F89 RID: 12169
			// (get) Token: 0x06008C01 RID: 35841 RVA: 0x0023E36C File Offset: 0x0023C56C
			public unsafe IKSolverVR.VirtualBone lastBone
			{
				[CallerCount(5)]
				[CachedScanResults(RefRangeStart = 632895, RefRangeEnd = 632900, XrefRangeStart = 632895, XrefRangeEnd = 632895, 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: 0x17002F8A RID: 12170
			// (get) Token: 0x06008C02 RID: 35842 RVA: 0x0023E3C4 File Offset: 0x0023C5C4
			// (set) Token: 0x06008C03 RID: 35843 RVA: 0x0023E414 File Offset: 0x0023C614
			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: 0x06008C04 RID: 35844 RVA: 0x0023E468 File Offset: 0x0023C668
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 632900, XrefRangeEnd = 632938, 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: 0x06008C05 RID: 35845 RVA: 0x0023E558 File Offset: 0x0023C758
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 632938, XrefRangeEnd = 632952, 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: 0x06008C06 RID: 35846 RVA: 0x0023E5A8 File Offset: 0x0023C7A8
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 632952, XrefRangeEnd = 632972, 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: 0x06008C07 RID: 35847 RVA: 0x0023E5F8 File Offset: 0x0023C7F8
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 632972, RefRangeEnd = 632974, XrefRangeStart = 632972, XrefRangeEnd = 632972, 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: 0x06008C08 RID: 35848 RVA: 0x0023E660 File Offset: 0x0023C860
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 632980, RefRangeEnd = 632982, XrefRangeStart = 632974, XrefRangeEnd = 632980, 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: 0x06008C09 RID: 35849 RVA: 0x0023E6C8 File Offset: 0x0023C8C8
			[CallerCount(4)]
			[CachedScanResults(RefRangeStart = 632991, RefRangeEnd = 632995, XrefRangeStart = 632982, XrefRangeEnd = 632991, 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: 0x06008C0A RID: 35850 RVA: 0x0023E70C File Offset: 0x0023C90C
			[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: 0x06008C0B RID: 35851 RVA: 0x0023E78C File Offset: 0x0023C98C
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 632995, XrefRangeEnd = 632998, 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: 0x06008C0C RID: 35852 RVA: 0x0023E7DC File Offset: 0x0023C9DC
			[CallerCount(3)]
			[CachedScanResults(RefRangeStart = 633008, RefRangeEnd = 633011, XrefRangeStart = 632998, XrefRangeEnd = 633008, 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: 0x06008C0D RID: 35853 RVA: 0x0023E828 File Offset: 0x0023CA28
			// 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, 100674035);
				IKSolverVR.Leg.NativeMethodInfoPtr_set_position_Private_set_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100674036);
				IKSolverVR.Leg.NativeMethodInfoPtr_get_rotation_Public_get_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100674037);
				IKSolverVR.Leg.NativeMethodInfoPtr_set_rotation_Private_set_Void_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100674038);
				IKSolverVR.Leg.NativeMethodInfoPtr_get_hasToes_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100674039);
				IKSolverVR.Leg.NativeMethodInfoPtr_set_hasToes_Private_set_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100674040);
				IKSolverVR.Leg.NativeMethodInfoPtr_get_thigh_Public_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100674041);
				IKSolverVR.Leg.NativeMethodInfoPtr_get_calf_Private_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100674042);
				IKSolverVR.Leg.NativeMethodInfoPtr_get_foot_Private_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100674043);
				IKSolverVR.Leg.NativeMethodInfoPtr_get_toes_Private_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100674044);
				IKSolverVR.Leg.NativeMethodInfoPtr_get_lastBone_Public_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100674045);
				IKSolverVR.Leg.NativeMethodInfoPtr_get_thighRelativeToPelvis_Public_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100674046);
				IKSolverVR.Leg.NativeMethodInfoPtr_set_thighRelativeToPelvis_Private_set_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100674047);
				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, 100674048);
				IKSolverVR.Leg.NativeMethodInfoPtr_PreSolve_Public_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100674049);
				IKSolverVR.Leg.NativeMethodInfoPtr_ApplyOffsets_Public_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100674050);
				IKSolverVR.Leg.NativeMethodInfoPtr_ApplyPositionOffset_Private_Void_Vector3_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100674051);
				IKSolverVR.Leg.NativeMethodInfoPtr_ApplyRotationOffset_Private_Void_Quaternion_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100674052);
				IKSolverVR.Leg.NativeMethodInfoPtr_Solve_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100674053);
				IKSolverVR.Leg.NativeMethodInfoPtr_Write_Public_Virtual_Void_byref_Il2CppStructArray_1_Vector3_byref_Il2CppStructArray_1_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100674054);
				IKSolverVR.Leg.NativeMethodInfoPtr_ResetOffsets_Public_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100674055);
				IKSolverVR.Leg.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Leg>.NativeClassPtr, 100674056);
			}

			// Token: 0x06008C0E RID: 35854 RVA: 0x0023C323 File Offset: 0x0023A523
			public Leg(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002F6E RID: 12142
			// (get) Token: 0x06008C0F RID: 35855 RVA: 0x0023EB9C File Offset: 0x0023CD9C
			// (set) Token: 0x06008C10 RID: 35856 RVA: 0x0023EBD0 File Offset: 0x0023CDD0
			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: 0x17002F6F RID: 12143
			// (get) Token: 0x06008C11 RID: 35857 RVA: 0x0023EBF8 File Offset: 0x0023CDF8
			// (set) Token: 0x06008C12 RID: 35858 RVA: 0x0023EC2C File Offset: 0x0023CE2C
			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: 0x17002F70 RID: 12144
			// (get) Token: 0x06008C13 RID: 35859 RVA: 0x0023EC54 File Offset: 0x0023CE54
			// (set) Token: 0x06008C14 RID: 35860 RVA: 0x0023EC7C File Offset: 0x0023CE7C
			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: 0x17002F71 RID: 12145
			// (get) Token: 0x06008C15 RID: 35861 RVA: 0x0023ECA0 File Offset: 0x0023CEA0
			// (set) Token: 0x06008C16 RID: 35862 RVA: 0x0023ECC8 File Offset: 0x0023CEC8
			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: 0x17002F72 RID: 12146
			// (get) Token: 0x06008C17 RID: 35863 RVA: 0x0023ECEC File Offset: 0x0023CEEC
			// (set) Token: 0x06008C18 RID: 35864 RVA: 0x0023ED14 File Offset: 0x0023CF14
			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: 0x17002F73 RID: 12147
			// (get) Token: 0x06008C19 RID: 35865 RVA: 0x0023ED38 File Offset: 0x0023CF38
			// (set) Token: 0x06008C1A RID: 35866 RVA: 0x0023ED60 File Offset: 0x0023CF60
			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: 0x17002F74 RID: 12148
			// (get) Token: 0x06008C1B RID: 35867 RVA: 0x0023ED84 File Offset: 0x0023CF84
			// (set) Token: 0x06008C1C RID: 35868 RVA: 0x0023EDAC File Offset: 0x0023CFAC
			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: 0x17002F75 RID: 12149
			// (get) Token: 0x06008C1D RID: 35869 RVA: 0x0023EDD0 File Offset: 0x0023CFD0
			// (set) Token: 0x06008C1E RID: 35870 RVA: 0x0023EDF8 File Offset: 0x0023CFF8
			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: 0x17002F76 RID: 12150
			// (get) Token: 0x06008C1F RID: 35871 RVA: 0x0023EE1C File Offset: 0x0023D01C
			// (set) Token: 0x06008C20 RID: 35872 RVA: 0x0023EE44 File Offset: 0x0023D044
			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: 0x17002F77 RID: 12151
			// (get) Token: 0x06008C21 RID: 35873 RVA: 0x0023EE68 File Offset: 0x0023D068
			// (set) Token: 0x06008C22 RID: 35874 RVA: 0x0023EE90 File Offset: 0x0023D090
			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: 0x17002F78 RID: 12152
			// (get) Token: 0x06008C23 RID: 35875 RVA: 0x0023EEB4 File Offset: 0x0023D0B4
			// (set) Token: 0x06008C24 RID: 35876 RVA: 0x0023EEDC File Offset: 0x0023D0DC
			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: 0x17002F79 RID: 12153
			// (get) Token: 0x06008C25 RID: 35877 RVA: 0x0023EF00 File Offset: 0x0023D100
			// (set) Token: 0x06008C26 RID: 35878 RVA: 0x0023EF28 File Offset: 0x0023D128
			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: 0x17002F7A RID: 12154
			// (get) Token: 0x06008C27 RID: 35879 RVA: 0x0023EF4C File Offset: 0x0023D14C
			// (set) Token: 0x06008C28 RID: 35880 RVA: 0x0023EF74 File Offset: 0x0023D174
			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: 0x17002F7B RID: 12155
			// (get) Token: 0x06008C29 RID: 35881 RVA: 0x0023EF98 File Offset: 0x0023D198
			// (set) Token: 0x06008C2A RID: 35882 RVA: 0x0023EFC0 File Offset: 0x0023D1C0
			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: 0x17002F7C RID: 12156
			// (get) Token: 0x06008C2B RID: 35883 RVA: 0x0023EFE4 File Offset: 0x0023D1E4
			// (set) Token: 0x06008C2C RID: 35884 RVA: 0x0023F00C File Offset: 0x0023D20C
			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: 0x17002F7D RID: 12157
			// (get) Token: 0x06008C2D RID: 35885 RVA: 0x0023F030 File Offset: 0x0023D230
			// (set) Token: 0x06008C2E RID: 35886 RVA: 0x0023F058 File Offset: 0x0023D258
			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: 0x17002F7E RID: 12158
			// (get) Token: 0x06008C2F RID: 35887 RVA: 0x0023F07C File Offset: 0x0023D27C
			// (set) Token: 0x06008C30 RID: 35888 RVA: 0x0023F0A4 File Offset: 0x0023D2A4
			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: 0x17002F7F RID: 12159
			// (get) Token: 0x06008C31 RID: 35889 RVA: 0x0023F0C8 File Offset: 0x0023D2C8
			// (set) Token: 0x06008C32 RID: 35890 RVA: 0x0023F0F0 File Offset: 0x0023D2F0
			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: 0x17002F80 RID: 12160
			// (get) Token: 0x06008C33 RID: 35891 RVA: 0x0023F114 File Offset: 0x0023D314
			// (set) Token: 0x06008C34 RID: 35892 RVA: 0x0023F13C File Offset: 0x0023D33C
			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: 0x17002F81 RID: 12161
			// (get) Token: 0x06008C35 RID: 35893 RVA: 0x0023F160 File Offset: 0x0023D360
			// (set) Token: 0x06008C36 RID: 35894 RVA: 0x0023F188 File Offset: 0x0023D388
			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: 0x04005DA1 RID: 23969
			private static readonly IntPtr NativeFieldInfoPtr_target;

			// Token: 0x04005DA2 RID: 23970
			private static readonly IntPtr NativeFieldInfoPtr_bendGoal;

			// Token: 0x04005DA3 RID: 23971
			private static readonly IntPtr NativeFieldInfoPtr_positionWeight;

			// Token: 0x04005DA4 RID: 23972
			private static readonly IntPtr NativeFieldInfoPtr_rotationWeight;

			// Token: 0x04005DA5 RID: 23973
			private static readonly IntPtr NativeFieldInfoPtr_bendGoalWeight;

			// Token: 0x04005DA6 RID: 23974
			private static readonly IntPtr NativeFieldInfoPtr_swivelOffset;

			// Token: 0x04005DA7 RID: 23975
			private static readonly IntPtr NativeFieldInfoPtr_IKPosition;

			// Token: 0x04005DA8 RID: 23976
			private static readonly IntPtr NativeFieldInfoPtr_IKRotation;

			// Token: 0x04005DA9 RID: 23977
			private static readonly IntPtr NativeFieldInfoPtr_footPositionOffset;

			// Token: 0x04005DAA RID: 23978
			private static readonly IntPtr NativeFieldInfoPtr_heelPositionOffset;

			// Token: 0x04005DAB RID: 23979
			private static readonly IntPtr NativeFieldInfoPtr_footRotationOffset;

			// Token: 0x04005DAC RID: 23980
			private static readonly IntPtr NativeFieldInfoPtr_currentMag;

			// Token: 0x04005DAD RID: 23981
			private static readonly IntPtr NativeFieldInfoPtr__position_k__BackingField;

			// Token: 0x04005DAE RID: 23982
			private static readonly IntPtr NativeFieldInfoPtr__rotation_k__BackingField;

			// Token: 0x04005DAF RID: 23983
			private static readonly IntPtr NativeFieldInfoPtr__hasToes_k__BackingField;

			// Token: 0x04005DB0 RID: 23984
			private static readonly IntPtr NativeFieldInfoPtr__thighRelativeToPelvis_k__BackingField;

			// Token: 0x04005DB1 RID: 23985
			private static readonly IntPtr NativeFieldInfoPtr_footPosition;

			// Token: 0x04005DB2 RID: 23986
			private static readonly IntPtr NativeFieldInfoPtr_footRotation;

			// Token: 0x04005DB3 RID: 23987
			private static readonly IntPtr NativeFieldInfoPtr_bendNormal;

			// Token: 0x04005DB4 RID: 23988
			private static readonly IntPtr NativeFieldInfoPtr_calfRelToThigh;

			// Token: 0x04005DB5 RID: 23989
			private static readonly IntPtr NativeMethodInfoPtr_get_position_Public_get_Vector3_0;

			// Token: 0x04005DB6 RID: 23990
			private static readonly IntPtr NativeMethodInfoPtr_set_position_Private_set_Void_Vector3_0;

			// Token: 0x04005DB7 RID: 23991
			private static readonly IntPtr NativeMethodInfoPtr_get_rotation_Public_get_Quaternion_0;

			// Token: 0x04005DB8 RID: 23992
			private static readonly IntPtr NativeMethodInfoPtr_set_rotation_Private_set_Void_Quaternion_0;

			// Token: 0x04005DB9 RID: 23993
			private static readonly IntPtr NativeMethodInfoPtr_get_hasToes_Public_get_Boolean_0;

			// Token: 0x04005DBA RID: 23994
			private static readonly IntPtr NativeMethodInfoPtr_set_hasToes_Private_set_Void_Boolean_0;

			// Token: 0x04005DBB RID: 23995
			private static readonly IntPtr NativeMethodInfoPtr_get_thigh_Public_get_VirtualBone_0;

			// Token: 0x04005DBC RID: 23996
			private static readonly IntPtr NativeMethodInfoPtr_get_calf_Private_get_VirtualBone_0;

			// Token: 0x04005DBD RID: 23997
			private static readonly IntPtr NativeMethodInfoPtr_get_foot_Private_get_VirtualBone_0;

			// Token: 0x04005DBE RID: 23998
			private static readonly IntPtr NativeMethodInfoPtr_get_toes_Private_get_VirtualBone_0;

			// Token: 0x04005DBF RID: 23999
			private static readonly IntPtr NativeMethodInfoPtr_get_lastBone_Public_get_VirtualBone_0;

			// Token: 0x04005DC0 RID: 24000
			private static readonly IntPtr NativeMethodInfoPtr_get_thighRelativeToPelvis_Public_get_Vector3_0;

			// Token: 0x04005DC1 RID: 24001
			private static readonly IntPtr NativeMethodInfoPtr_set_thighRelativeToPelvis_Private_set_Void_Vector3_0;

			// Token: 0x04005DC2 RID: 24002
			private static readonly IntPtr NativeMethodInfoPtr_OnRead_Protected_Virtual_Void_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Quaternion_Boolean_Boolean_Boolean_Boolean_Int32_Int32_0;

			// Token: 0x04005DC3 RID: 24003
			private static readonly IntPtr NativeMethodInfoPtr_PreSolve_Public_Virtual_Void_0;

			// Token: 0x04005DC4 RID: 24004
			private static readonly IntPtr NativeMethodInfoPtr_ApplyOffsets_Public_Virtual_Void_0;

			// Token: 0x04005DC5 RID: 24005
			private static readonly IntPtr NativeMethodInfoPtr_ApplyPositionOffset_Private_Void_Vector3_Single_0;

			// Token: 0x04005DC6 RID: 24006
			private static readonly IntPtr NativeMethodInfoPtr_ApplyRotationOffset_Private_Void_Quaternion_Single_0;

			// Token: 0x04005DC7 RID: 24007
			private static readonly IntPtr NativeMethodInfoPtr_Solve_Public_Void_0;

			// Token: 0x04005DC8 RID: 24008
			private static readonly IntPtr NativeMethodInfoPtr_Write_Public_Virtual_Void_byref_Il2CppStructArray_1_Vector3_byref_Il2CppStructArray_1_Quaternion_0;

			// Token: 0x04005DC9 RID: 24009
			private static readonly IntPtr NativeMethodInfoPtr_ResetOffsets_Public_Virtual_Void_0;

			// Token: 0x04005DCA RID: 24010
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
		}

		// Token: 0x020004A6 RID: 1190
		[Serializable]
		public class Locomotion : Il2CppSystem.Object
		{
			// Token: 0x17002FA7 RID: 12199
			// (get) Token: 0x06008C37 RID: 35895 RVA: 0x0023F1AC File Offset: 0x0023D3AC
			// (set) Token: 0x06008C38 RID: 35896 RVA: 0x0023F1FC File Offset: 0x0023D3FC
			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: 0x06008C39 RID: 35897 RVA: 0x0023F250 File Offset: 0x0023D450
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 633063, RefRangeEnd = 633064, XrefRangeStart = 633011, XrefRangeEnd = 633063, 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: 0x06008C3A RID: 35898 RVA: 0x0023F2D4 File Offset: 0x0023D4D4
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 633071, RefRangeEnd = 633072, XrefRangeStart = 633064, XrefRangeEnd = 633071, 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: 0x06008C3B RID: 35899 RVA: 0x0023F348 File Offset: 0x0023D548
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 633081, RefRangeEnd = 633082, XrefRangeStart = 633072, XrefRangeEnd = 633081, 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: 0x06008C3C RID: 35900 RVA: 0x0023F3B0 File Offset: 0x0023D5B0
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 633083, RefRangeEnd = 633084, XrefRangeStart = 633082, XrefRangeEnd = 633083, 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: 0x06008C3D RID: 35901 RVA: 0x0023F404 File Offset: 0x0023D604
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 633143, RefRangeEnd = 633144, XrefRangeStart = 633084, XrefRangeEnd = 633143, 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: 0x17002FA8 RID: 12200
			// (get) Token: 0x06008C3E RID: 35902 RVA: 0x0023F590 File Offset: 0x0023D790
			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: 0x17002FA9 RID: 12201
			// (get) Token: 0x06008C3F RID: 35903 RVA: 0x0023F5E0 File Offset: 0x0023D7E0
			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: 0x17002FAA RID: 12202
			// (get) Token: 0x06008C40 RID: 35904 RVA: 0x0023F630 File Offset: 0x0023D830
			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: 0x17002FAB RID: 12203
			// (get) Token: 0x06008C41 RID: 35905 RVA: 0x0023F680 File Offset: 0x0023D880
			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: 0x06008C42 RID: 35906 RVA: 0x0023F6D0 File Offset: 0x0023D8D0
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 633148, RefRangeEnd = 633150, XrefRangeStart = 633144, XrefRangeEnd = 633148, 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: 0x06008C43 RID: 35907 RVA: 0x0023F758 File Offset: 0x0023D958
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 633150, XrefRangeEnd = 633151, 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: 0x06008C44 RID: 35908 RVA: 0x0023F7A8 File Offset: 0x0023D9A8
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 633158, RefRangeEnd = 633159, XrefRangeStart = 633151, XrefRangeEnd = 633158, 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: 0x06008C45 RID: 35909 RVA: 0x0023F834 File Offset: 0x0023DA34
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 633173, RefRangeEnd = 633174, XrefRangeStart = 633159, XrefRangeEnd = 633173, 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: 0x06008C46 RID: 35910 RVA: 0x0023F880 File Offset: 0x0023DA80
			// 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, 100674057);
				IKSolverVR.Locomotion.NativeMethodInfoPtr_set_centerOfMass_Private_set_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, 100674058);
				IKSolverVR.Locomotion.NativeMethodInfoPtr_Initiate_Public_Void_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Quaternion_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, 100674059);
				IKSolverVR.Locomotion.NativeMethodInfoPtr_Reset_Public_Void_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, 100674060);
				IKSolverVR.Locomotion.NativeMethodInfoPtr_AddDeltaRotation_Public_Void_Quaternion_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, 100674061);
				IKSolverVR.Locomotion.NativeMethodInfoPtr_AddDeltaPosition_Public_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, 100674062);
				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, 100674063);
				IKSolverVR.Locomotion.NativeMethodInfoPtr_get_leftFootstepPosition_Public_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, 100674064);
				IKSolverVR.Locomotion.NativeMethodInfoPtr_get_rightFootstepPosition_Public_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, 100674065);
				IKSolverVR.Locomotion.NativeMethodInfoPtr_get_leftFootstepRotation_Public_get_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, 100674066);
				IKSolverVR.Locomotion.NativeMethodInfoPtr_get_rightFootstepRotation_Public_get_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, 100674067);
				IKSolverVR.Locomotion.NativeMethodInfoPtr_StepBlocked_Private_Boolean_Vector3_Vector3_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, 100674068);
				IKSolverVR.Locomotion.NativeMethodInfoPtr_CanStep_Private_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, 100674069);
				IKSolverVR.Locomotion.NativeMethodInfoPtr_GetLineSphereCollision_Private_Static_Boolean_Vector3_Vector3_Vector3_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, 100674070);
				IKSolverVR.Locomotion.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Locomotion>.NativeClassPtr, 100674071);
			}

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

			// Token: 0x17002F8B RID: 12171
			// (get) Token: 0x06008C48 RID: 35912 RVA: 0x0023FC08 File Offset: 0x0023DE08
			// (set) Token: 0x06008C49 RID: 35913 RVA: 0x0023FC30 File Offset: 0x0023DE30
			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: 0x17002F8C RID: 12172
			// (get) Token: 0x06008C4A RID: 35914 RVA: 0x0023FC54 File Offset: 0x0023DE54
			// (set) Token: 0x06008C4B RID: 35915 RVA: 0x0023FC7C File Offset: 0x0023DE7C
			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: 0x17002F8D RID: 12173
			// (get) Token: 0x06008C4C RID: 35916 RVA: 0x0023FCA0 File Offset: 0x0023DEA0
			// (set) Token: 0x06008C4D RID: 35917 RVA: 0x0023FCC8 File Offset: 0x0023DEC8
			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: 0x17002F8E RID: 12174
			// (get) Token: 0x06008C4E RID: 35918 RVA: 0x0023FCEC File Offset: 0x0023DEEC
			// (set) Token: 0x06008C4F RID: 35919 RVA: 0x0023FD14 File Offset: 0x0023DF14
			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: 0x17002F8F RID: 12175
			// (get) Token: 0x06008C50 RID: 35920 RVA: 0x0023FD38 File Offset: 0x0023DF38
			// (set) Token: 0x06008C51 RID: 35921 RVA: 0x0023FD60 File Offset: 0x0023DF60
			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: 0x17002F90 RID: 12176
			// (get) Token: 0x06008C52 RID: 35922 RVA: 0x0023FD84 File Offset: 0x0023DF84
			// (set) Token: 0x06008C53 RID: 35923 RVA: 0x0023FDAC File Offset: 0x0023DFAC
			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: 0x17002F91 RID: 12177
			// (get) Token: 0x06008C54 RID: 35924 RVA: 0x0023FDD0 File Offset: 0x0023DFD0
			// (set) Token: 0x06008C55 RID: 35925 RVA: 0x0023FDF8 File Offset: 0x0023DFF8
			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: 0x17002F92 RID: 12178
			// (get) Token: 0x06008C56 RID: 35926 RVA: 0x0023FE1C File Offset: 0x0023E01C
			// (set) Token: 0x06008C57 RID: 35927 RVA: 0x0023FE44 File Offset: 0x0023E044
			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: 0x17002F93 RID: 12179
			// (get) Token: 0x06008C58 RID: 35928 RVA: 0x0023FE68 File Offset: 0x0023E068
			// (set) Token: 0x06008C59 RID: 35929 RVA: 0x0023FE90 File Offset: 0x0023E090
			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: 0x17002F94 RID: 12180
			// (get) Token: 0x06008C5A RID: 35930 RVA: 0x0023FEB4 File Offset: 0x0023E0B4
			// (set) Token: 0x06008C5B RID: 35931 RVA: 0x0023FEDC File Offset: 0x0023E0DC
			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: 0x17002F95 RID: 12181
			// (get) Token: 0x06008C5C RID: 35932 RVA: 0x0023FF00 File Offset: 0x0023E100
			// (set) Token: 0x06008C5D RID: 35933 RVA: 0x0023FF34 File Offset: 0x0023E134
			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: 0x17002F96 RID: 12182
			// (get) Token: 0x06008C5E RID: 35934 RVA: 0x0023FF5C File Offset: 0x0023E15C
			// (set) Token: 0x06008C5F RID: 35935 RVA: 0x0023FF90 File Offset: 0x0023E190
			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: 0x17002F97 RID: 12183
			// (get) Token: 0x06008C60 RID: 35936 RVA: 0x0023FFB8 File Offset: 0x0023E1B8
			// (set) Token: 0x06008C61 RID: 35937 RVA: 0x0023FFE0 File Offset: 0x0023E1E0
			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: 0x17002F98 RID: 12184
			// (get) Token: 0x06008C62 RID: 35938 RVA: 0x00240004 File Offset: 0x0023E204
			// (set) Token: 0x06008C63 RID: 35939 RVA: 0x0024002C File Offset: 0x0023E22C
			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: 0x17002F99 RID: 12185
			// (get) Token: 0x06008C64 RID: 35940 RVA: 0x00240050 File Offset: 0x0023E250
			// (set) Token: 0x06008C65 RID: 35941 RVA: 0x00240078 File Offset: 0x0023E278
			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: 0x17002F9A RID: 12186
			// (get) Token: 0x06008C66 RID: 35942 RVA: 0x0024009C File Offset: 0x0023E29C
			// (set) Token: 0x06008C67 RID: 35943 RVA: 0x002400C4 File Offset: 0x0023E2C4
			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: 0x17002F9B RID: 12187
			// (get) Token: 0x06008C68 RID: 35944 RVA: 0x002400E8 File Offset: 0x0023E2E8
			// (set) Token: 0x06008C69 RID: 35945 RVA: 0x00240110 File Offset: 0x0023E310
			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: 0x17002F9C RID: 12188
			// (get) Token: 0x06008C6A RID: 35946 RVA: 0x00240134 File Offset: 0x0023E334
			// (set) Token: 0x06008C6B RID: 35947 RVA: 0x0024015C File Offset: 0x0023E35C
			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: 0x17002F9D RID: 12189
			// (get) Token: 0x06008C6C RID: 35948 RVA: 0x00240180 File Offset: 0x0023E380
			// (set) Token: 0x06008C6D RID: 35949 RVA: 0x002401A8 File Offset: 0x0023E3A8
			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: 0x17002F9E RID: 12190
			// (get) Token: 0x06008C6E RID: 35950 RVA: 0x002401CC File Offset: 0x0023E3CC
			// (set) Token: 0x06008C6F RID: 35951 RVA: 0x002401F4 File Offset: 0x0023E3F4
			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: 0x17002F9F RID: 12191
			// (get) Token: 0x06008C70 RID: 35952 RVA: 0x00240218 File Offset: 0x0023E418
			// (set) Token: 0x06008C71 RID: 35953 RVA: 0x0024024C File Offset: 0x0023E44C
			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: 0x17002FA0 RID: 12192
			// (get) Token: 0x06008C72 RID: 35954 RVA: 0x00240274 File Offset: 0x0023E474
			// (set) Token: 0x06008C73 RID: 35955 RVA: 0x002402A8 File Offset: 0x0023E4A8
			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: 0x17002FA1 RID: 12193
			// (get) Token: 0x06008C74 RID: 35956 RVA: 0x002402D0 File Offset: 0x0023E4D0
			// (set) Token: 0x06008C75 RID: 35957 RVA: 0x002402F8 File Offset: 0x0023E4F8
			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: 0x17002FA2 RID: 12194
			// (get) Token: 0x06008C76 RID: 35958 RVA: 0x0024031C File Offset: 0x0023E51C
			// (set) Token: 0x06008C77 RID: 35959 RVA: 0x00240350 File Offset: 0x0023E550
			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: 0x17002FA3 RID: 12195
			// (get) Token: 0x06008C78 RID: 35960 RVA: 0x00240378 File Offset: 0x0023E578
			// (set) Token: 0x06008C79 RID: 35961 RVA: 0x002403A0 File Offset: 0x0023E5A0
			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: 0x17002FA4 RID: 12196
			// (get) Token: 0x06008C7A RID: 35962 RVA: 0x002403C4 File Offset: 0x0023E5C4
			// (set) Token: 0x06008C7B RID: 35963 RVA: 0x002403EC File Offset: 0x0023E5EC
			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: 0x17002FA5 RID: 12197
			// (get) Token: 0x06008C7C RID: 35964 RVA: 0x00240410 File Offset: 0x0023E610
			// (set) Token: 0x06008C7D RID: 35965 RVA: 0x00240438 File Offset: 0x0023E638
			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: 0x17002FA6 RID: 12198
			// (get) Token: 0x06008C7E RID: 35966 RVA: 0x0024045C File Offset: 0x0023E65C
			// (set) Token: 0x06008C7F RID: 35967 RVA: 0x00240484 File Offset: 0x0023E684
			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: 0x04005DCB RID: 24011
			private static readonly IntPtr NativeFieldInfoPtr_weight;

			// Token: 0x04005DCC RID: 24012
			private static readonly IntPtr NativeFieldInfoPtr_footDistance;

			// Token: 0x04005DCD RID: 24013
			private static readonly IntPtr NativeFieldInfoPtr_stepThreshold;

			// Token: 0x04005DCE RID: 24014
			private static readonly IntPtr NativeFieldInfoPtr_angleThreshold;

			// Token: 0x04005DCF RID: 24015
			private static readonly IntPtr NativeFieldInfoPtr_comAngleMlp;

			// Token: 0x04005DD0 RID: 24016
			private static readonly IntPtr NativeFieldInfoPtr_maxVelocity;

			// Token: 0x04005DD1 RID: 24017
			private static readonly IntPtr NativeFieldInfoPtr_velocityFactor;

			// Token: 0x04005DD2 RID: 24018
			private static readonly IntPtr NativeFieldInfoPtr_maxLegStretch;

			// Token: 0x04005DD3 RID: 24019
			private static readonly IntPtr NativeFieldInfoPtr_rootSpeed;

			// Token: 0x04005DD4 RID: 24020
			private static readonly IntPtr NativeFieldInfoPtr_stepSpeed;

			// Token: 0x04005DD5 RID: 24021
			private static readonly IntPtr NativeFieldInfoPtr_stepHeight;

			// Token: 0x04005DD6 RID: 24022
			private static readonly IntPtr NativeFieldInfoPtr_heelHeight;

			// Token: 0x04005DD7 RID: 24023
			private static readonly IntPtr NativeFieldInfoPtr_relaxLegTwistMinAngle;

			// Token: 0x04005DD8 RID: 24024
			private static readonly IntPtr NativeFieldInfoPtr_relaxLegTwistSpeed;

			// Token: 0x04005DD9 RID: 24025
			private static readonly IntPtr NativeFieldInfoPtr_stepInterpolation;

			// Token: 0x04005DDA RID: 24026
			private static readonly IntPtr NativeFieldInfoPtr_offset;

			// Token: 0x04005DDB RID: 24027
			private static readonly IntPtr NativeFieldInfoPtr_blockingEnabled;

			// Token: 0x04005DDC RID: 24028
			private static readonly IntPtr NativeFieldInfoPtr_blockingLayers;

			// Token: 0x04005DDD RID: 24029
			private static readonly IntPtr NativeFieldInfoPtr_raycastRadius;

			// Token: 0x04005DDE RID: 24030
			private static readonly IntPtr NativeFieldInfoPtr_raycastHeight;

			// Token: 0x04005DDF RID: 24031
			private static readonly IntPtr NativeFieldInfoPtr_onLeftFootstep;

			// Token: 0x04005DE0 RID: 24032
			private static readonly IntPtr NativeFieldInfoPtr_onRightFootstep;

			// Token: 0x04005DE1 RID: 24033
			private static readonly IntPtr NativeFieldInfoPtr__centerOfMass_k__BackingField;

			// Token: 0x04005DE2 RID: 24034
			private static readonly IntPtr NativeFieldInfoPtr_footsteps;

			// Token: 0x04005DE3 RID: 24035
			private static readonly IntPtr NativeFieldInfoPtr_lastComPosition;

			// Token: 0x04005DE4 RID: 24036
			private static readonly IntPtr NativeFieldInfoPtr_comVelocity;

			// Token: 0x04005DE5 RID: 24037
			private static readonly IntPtr NativeFieldInfoPtr_leftFootIndex;

			// Token: 0x04005DE6 RID: 24038
			private static readonly IntPtr NativeFieldInfoPtr_rightFootIndex;

			// Token: 0x04005DE7 RID: 24039
			private static readonly IntPtr NativeMethodInfoPtr_get_centerOfMass_Public_get_Vector3_0;

			// Token: 0x04005DE8 RID: 24040
			private static readonly IntPtr NativeMethodInfoPtr_set_centerOfMass_Private_set_Void_Vector3_0;

			// Token: 0x04005DE9 RID: 24041
			private static readonly IntPtr NativeMethodInfoPtr_Initiate_Public_Void_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Quaternion_Boolean_0;

			// Token: 0x04005DEA RID: 24042
			private static readonly IntPtr NativeMethodInfoPtr_Reset_Public_Void_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Quaternion_0;

			// Token: 0x04005DEB RID: 24043
			private static readonly IntPtr NativeMethodInfoPtr_AddDeltaRotation_Public_Void_Quaternion_Vector3_0;

			// Token: 0x04005DEC RID: 24044
			private static readonly IntPtr NativeMethodInfoPtr_AddDeltaPosition_Public_Void_Vector3_0;

			// Token: 0x04005DED RID: 24045
			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: 0x04005DEE RID: 24046
			private static readonly IntPtr NativeMethodInfoPtr_get_leftFootstepPosition_Public_get_Vector3_0;

			// Token: 0x04005DEF RID: 24047
			private static readonly IntPtr NativeMethodInfoPtr_get_rightFootstepPosition_Public_get_Vector3_0;

			// Token: 0x04005DF0 RID: 24048
			private static readonly IntPtr NativeMethodInfoPtr_get_leftFootstepRotation_Public_get_Quaternion_0;

			// Token: 0x04005DF1 RID: 24049
			private static readonly IntPtr NativeMethodInfoPtr_get_rightFootstepRotation_Public_get_Quaternion_0;

			// Token: 0x04005DF2 RID: 24050
			private static readonly IntPtr NativeMethodInfoPtr_StepBlocked_Private_Boolean_Vector3_Vector3_Vector3_0;

			// Token: 0x04005DF3 RID: 24051
			private static readonly IntPtr NativeMethodInfoPtr_CanStep_Private_Boolean_0;

			// Token: 0x04005DF4 RID: 24052
			private static readonly IntPtr NativeMethodInfoPtr_GetLineSphereCollision_Private_Static_Boolean_Vector3_Vector3_Vector3_Single_0;

			// Token: 0x04005DF5 RID: 24053
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
		}

		// Token: 0x020004A7 RID: 1191
		[Serializable]
		public class Spine : IKSolverVR.BodyPart
		{
			// Token: 0x17002FDD RID: 12253
			// (get) Token: 0x06008C80 RID: 35968 RVA: 0x002404A8 File Offset: 0x0023E6A8
			public unsafe IKSolverVR.VirtualBone pelvis
			{
				[CallerCount(14)]
				[CachedScanResults(RefRangeStart = 633174, RefRangeEnd = 633188, XrefRangeStart = 633174, XrefRangeEnd = 633174, 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: 0x17002FDE RID: 12254
			// (get) Token: 0x06008C81 RID: 35969 RVA: 0x00240500 File Offset: 0x0023E700
			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: 0x17002FDF RID: 12255
			// (get) Token: 0x06008C82 RID: 35970 RVA: 0x00240558 File Offset: 0x0023E758
			public unsafe IKSolverVR.VirtualBone chest
			{
				[CallerCount(2)]
				[CachedScanResults(RefRangeStart = 633189, RefRangeEnd = 633191, XrefRangeStart = 633188, XrefRangeEnd = 633189, 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: 0x17002FE0 RID: 12256
			// (get) Token: 0x06008C83 RID: 35971 RVA: 0x002405B0 File Offset: 0x0023E7B0
			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: 0x17002FE1 RID: 12257
			// (get) Token: 0x06008C84 RID: 35972 RVA: 0x00240608 File Offset: 0x0023E808
			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: 0x17002FE2 RID: 12258
			// (get) Token: 0x06008C85 RID: 35973 RVA: 0x00240660 File Offset: 0x0023E860
			// (set) Token: 0x06008C86 RID: 35974 RVA: 0x002406B0 File Offset: 0x0023E8B0
			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: 0x06008C87 RID: 35975 RVA: 0x00240704 File Offset: 0x0023E904
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 633191, XrefRangeEnd = 633244, 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: 0x06008C88 RID: 35976 RVA: 0x002407F4 File Offset: 0x0023E9F4
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 633244, XrefRangeEnd = 633261, 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: 0x06008C89 RID: 35977 RVA: 0x00240844 File Offset: 0x0023EA44
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 633261, XrefRangeEnd = 633279, 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: 0x06008C8A RID: 35978 RVA: 0x00240894 File Offset: 0x0023EA94
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 633279, XrefRangeEnd = 633288, 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: 0x06008C8B RID: 35979 RVA: 0x00240908 File Offset: 0x0023EB08
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 633331, RefRangeEnd = 633332, XrefRangeStart = 633288, XrefRangeEnd = 633331, 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: 0x06008C8C RID: 35980 RVA: 0x00240994 File Offset: 0x0023EB94
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 633342, RefRangeEnd = 633343, XrefRangeStart = 633332, XrefRangeEnd = 633342, 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: 0x06008C8D RID: 35981 RVA: 0x002409D8 File Offset: 0x0023EBD8
			[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: 0x06008C8E RID: 35982 RVA: 0x00240A58 File Offset: 0x0023EC58
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 633343, XrefRangeEnd = 633348, 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: 0x06008C8F RID: 35983 RVA: 0x00240AA8 File Offset: 0x0023ECA8
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 633360, RefRangeEnd = 633362, XrefRangeStart = 633348, XrefRangeEnd = 633360, 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: 0x06008C90 RID: 35984 RVA: 0x00240B18 File Offset: 0x0023ED18
			[CallerCount(3)]
			[CachedScanResults(RefRangeStart = 633365, RefRangeEnd = 633368, XrefRangeStart = 633362, XrefRangeEnd = 633365, 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: 0x06008C91 RID: 35985 RVA: 0x00240BC0 File Offset: 0x0023EDC0
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 633381, RefRangeEnd = 633382, XrefRangeStart = 633368, XrefRangeEnd = 633381, 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: 0x06008C92 RID: 35986 RVA: 0x00240C40 File Offset: 0x0023EE40
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 633388, RefRangeEnd = 633389, XrefRangeStart = 633382, XrefRangeEnd = 633388, 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: 0x06008C93 RID: 35987 RVA: 0x00240CE0 File Offset: 0x0023EEE0
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 633396, RefRangeEnd = 633397, XrefRangeStart = 633389, XrefRangeEnd = 633396, 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: 0x06008C94 RID: 35988 RVA: 0x00240DAC File Offset: 0x0023EFAC
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 633405, RefRangeEnd = 633407, XrefRangeStart = 633397, XrefRangeEnd = 633405, 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: 0x06008C95 RID: 35989 RVA: 0x00240E8C File Offset: 0x0023F08C
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 633424, RefRangeEnd = 633425, XrefRangeStart = 633407, XrefRangeEnd = 633424, 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: 0x06008C96 RID: 35990 RVA: 0x00240ED8 File Offset: 0x0023F0D8
			// 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, 100674072);
				IKSolverVR.Spine.NativeMethodInfoPtr_get_firstSpineBone_Public_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100674073);
				IKSolverVR.Spine.NativeMethodInfoPtr_get_chest_Public_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100674074);
				IKSolverVR.Spine.NativeMethodInfoPtr_get_neck_Private_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100674075);
				IKSolverVR.Spine.NativeMethodInfoPtr_get_head_Public_get_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100674076);
				IKSolverVR.Spine.NativeMethodInfoPtr_get_anchorRotation_Public_get_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100674077);
				IKSolverVR.Spine.NativeMethodInfoPtr_set_anchorRotation_Private_set_Void_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100674078);
				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, 100674079);
				IKSolverVR.Spine.NativeMethodInfoPtr_PreSolve_Public_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100674080);
				IKSolverVR.Spine.NativeMethodInfoPtr_ApplyOffsets_Public_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100674081);
				IKSolverVR.Spine.NativeMethodInfoPtr_CalculateChestTargetRotation_Private_Void_VirtualBone_Il2CppReferenceArray_1_Arm_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100674082);
				IKSolverVR.Spine.NativeMethodInfoPtr_Solve_Public_Void_VirtualBone_Il2CppReferenceArray_1_Leg_Il2CppReferenceArray_1_Arm_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100674083);
				IKSolverVR.Spine.NativeMethodInfoPtr_SolvePelvis_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100674084);
				IKSolverVR.Spine.NativeMethodInfoPtr_Write_Public_Virtual_Void_byref_Il2CppStructArray_1_Vector3_byref_Il2CppStructArray_1_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100674085);
				IKSolverVR.Spine.NativeMethodInfoPtr_ResetOffsets_Public_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100674086);
				IKSolverVR.Spine.NativeMethodInfoPtr_AdjustChestByHands_Private_Void_byref_Quaternion_Il2CppReferenceArray_1_Arm_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100674087);
				IKSolverVR.Spine.NativeMethodInfoPtr_InverseTranslateToHead_Public_Void_Il2CppReferenceArray_1_Leg_Boolean_Boolean_Vector3_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100674088);
				IKSolverVR.Spine.NativeMethodInfoPtr_TranslatePelvis_Private_Void_Il2CppReferenceArray_1_Leg_Vector3_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100674089);
				IKSolverVR.Spine.NativeMethodInfoPtr_LimitPelvisPosition_Private_Vector3_Il2CppReferenceArray_1_Leg_Vector3_Boolean_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100674090);
				IKSolverVR.Spine.NativeMethodInfoPtr_Bend_Private_Void_Il2CppReferenceArray_1_VirtualBone_Int32_Int32_Quaternion_Single_Boolean_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100674091);
				IKSolverVR.Spine.NativeMethodInfoPtr_Bend_Private_Void_Il2CppReferenceArray_1_VirtualBone_Int32_Int32_Quaternion_Quaternion_Single_Boolean_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100674092);
				IKSolverVR.Spine.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.Spine>.NativeClassPtr, 100674093);
			}

			// Token: 0x06008C97 RID: 35991 RVA: 0x0023C323 File Offset: 0x0023A523
			public Spine(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002FAC RID: 12204
			// (get) Token: 0x06008C98 RID: 35992 RVA: 0x00241490 File Offset: 0x0023F690
			// (set) Token: 0x06008C99 RID: 35993 RVA: 0x002414C4 File Offset: 0x0023F6C4
			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: 0x17002FAD RID: 12205
			// (get) Token: 0x06008C9A RID: 35994 RVA: 0x002414EC File Offset: 0x0023F6EC
			// (set) Token: 0x06008C9B RID: 35995 RVA: 0x00241520 File Offset: 0x0023F720
			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: 0x17002FAE RID: 12206
			// (get) Token: 0x06008C9C RID: 35996 RVA: 0x00241548 File Offset: 0x0023F748
			// (set) Token: 0x06008C9D RID: 35997 RVA: 0x00241570 File Offset: 0x0023F770
			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: 0x17002FAF RID: 12207
			// (get) Token: 0x06008C9E RID: 35998 RVA: 0x00241594 File Offset: 0x0023F794
			// (set) Token: 0x06008C9F RID: 35999 RVA: 0x002415BC File Offset: 0x0023F7BC
			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: 0x17002FB0 RID: 12208
			// (get) Token: 0x06008CA0 RID: 36000 RVA: 0x002415E0 File Offset: 0x0023F7E0
			// (set) Token: 0x06008CA1 RID: 36001 RVA: 0x00241608 File Offset: 0x0023F808
			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: 0x17002FB1 RID: 12209
			// (get) Token: 0x06008CA2 RID: 36002 RVA: 0x0024162C File Offset: 0x0023F82C
			// (set) Token: 0x06008CA3 RID: 36003 RVA: 0x00241654 File Offset: 0x0023F854
			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: 0x17002FB2 RID: 12210
			// (get) Token: 0x06008CA4 RID: 36004 RVA: 0x00241678 File Offset: 0x0023F878
			// (set) Token: 0x06008CA5 RID: 36005 RVA: 0x002416AC File Offset: 0x0023F8AC
			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: 0x17002FB3 RID: 12211
			// (get) Token: 0x06008CA6 RID: 36006 RVA: 0x002416D4 File Offset: 0x0023F8D4
			// (set) Token: 0x06008CA7 RID: 36007 RVA: 0x002416FC File Offset: 0x0023F8FC
			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: 0x17002FB4 RID: 12212
			// (get) Token: 0x06008CA8 RID: 36008 RVA: 0x00241720 File Offset: 0x0023F920
			// (set) Token: 0x06008CA9 RID: 36009 RVA: 0x00241748 File Offset: 0x0023F948
			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: 0x17002FB5 RID: 12213
			// (get) Token: 0x06008CAA RID: 36010 RVA: 0x0024176C File Offset: 0x0023F96C
			// (set) Token: 0x06008CAB RID: 36011 RVA: 0x00241794 File Offset: 0x0023F994
			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: 0x17002FB6 RID: 12214
			// (get) Token: 0x06008CAC RID: 36012 RVA: 0x002417B8 File Offset: 0x0023F9B8
			// (set) Token: 0x06008CAD RID: 36013 RVA: 0x002417E0 File Offset: 0x0023F9E0
			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: 0x17002FB7 RID: 12215
			// (get) Token: 0x06008CAE RID: 36014 RVA: 0x00241804 File Offset: 0x0023FA04
			// (set) Token: 0x06008CAF RID: 36015 RVA: 0x0024182C File Offset: 0x0023FA2C
			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: 0x17002FB8 RID: 12216
			// (get) Token: 0x06008CB0 RID: 36016 RVA: 0x00241850 File Offset: 0x0023FA50
			// (set) Token: 0x06008CB1 RID: 36017 RVA: 0x00241878 File Offset: 0x0023FA78
			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: 0x17002FB9 RID: 12217
			// (get) Token: 0x06008CB2 RID: 36018 RVA: 0x0024189C File Offset: 0x0023FA9C
			// (set) Token: 0x06008CB3 RID: 36019 RVA: 0x002418C4 File Offset: 0x0023FAC4
			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: 0x17002FBA RID: 12218
			// (get) Token: 0x06008CB4 RID: 36020 RVA: 0x002418E8 File Offset: 0x0023FAE8
			// (set) Token: 0x06008CB5 RID: 36021 RVA: 0x00241910 File Offset: 0x0023FB10
			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: 0x17002FBB RID: 12219
			// (get) Token: 0x06008CB6 RID: 36022 RVA: 0x00241934 File Offset: 0x0023FB34
			// (set) Token: 0x06008CB7 RID: 36023 RVA: 0x0024195C File Offset: 0x0023FB5C
			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: 0x17002FBC RID: 12220
			// (get) Token: 0x06008CB8 RID: 36024 RVA: 0x00241980 File Offset: 0x0023FB80
			// (set) Token: 0x06008CB9 RID: 36025 RVA: 0x002419A8 File Offset: 0x0023FBA8
			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: 0x17002FBD RID: 12221
			// (get) Token: 0x06008CBA RID: 36026 RVA: 0x002419CC File Offset: 0x0023FBCC
			// (set) Token: 0x06008CBB RID: 36027 RVA: 0x002419F4 File Offset: 0x0023FBF4
			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: 0x17002FBE RID: 12222
			// (get) Token: 0x06008CBC RID: 36028 RVA: 0x00241A18 File Offset: 0x0023FC18
			// (set) Token: 0x06008CBD RID: 36029 RVA: 0x00241A40 File Offset: 0x0023FC40
			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: 0x17002FBF RID: 12223
			// (get) Token: 0x06008CBE RID: 36030 RVA: 0x00241A64 File Offset: 0x0023FC64
			// (set) Token: 0x06008CBF RID: 36031 RVA: 0x00241A8C File Offset: 0x0023FC8C
			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: 0x17002FC0 RID: 12224
			// (get) Token: 0x06008CC0 RID: 36032 RVA: 0x00241AB0 File Offset: 0x0023FCB0
			// (set) Token: 0x06008CC1 RID: 36033 RVA: 0x00241AD8 File Offset: 0x0023FCD8
			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: 0x17002FC1 RID: 12225
			// (get) Token: 0x06008CC2 RID: 36034 RVA: 0x00241AFC File Offset: 0x0023FCFC
			// (set) Token: 0x06008CC3 RID: 36035 RVA: 0x00241B24 File Offset: 0x0023FD24
			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: 0x17002FC2 RID: 12226
			// (get) Token: 0x06008CC4 RID: 36036 RVA: 0x00241B48 File Offset: 0x0023FD48
			// (set) Token: 0x06008CC5 RID: 36037 RVA: 0x00241B70 File Offset: 0x0023FD70
			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: 0x17002FC3 RID: 12227
			// (get) Token: 0x06008CC6 RID: 36038 RVA: 0x00241B94 File Offset: 0x0023FD94
			// (set) Token: 0x06008CC7 RID: 36039 RVA: 0x00241BBC File Offset: 0x0023FDBC
			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: 0x17002FC4 RID: 12228
			// (get) Token: 0x06008CC8 RID: 36040 RVA: 0x00241BE0 File Offset: 0x0023FDE0
			// (set) Token: 0x06008CC9 RID: 36041 RVA: 0x00241C08 File Offset: 0x0023FE08
			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: 0x17002FC5 RID: 12229
			// (get) Token: 0x06008CCA RID: 36042 RVA: 0x00241C2C File Offset: 0x0023FE2C
			// (set) Token: 0x06008CCB RID: 36043 RVA: 0x00241C54 File Offset: 0x0023FE54
			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: 0x17002FC6 RID: 12230
			// (get) Token: 0x06008CCC RID: 36044 RVA: 0x00241C78 File Offset: 0x0023FE78
			// (set) Token: 0x06008CCD RID: 36045 RVA: 0x00241CA0 File Offset: 0x0023FEA0
			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: 0x17002FC7 RID: 12231
			// (get) Token: 0x06008CCE RID: 36046 RVA: 0x00241CC4 File Offset: 0x0023FEC4
			// (set) Token: 0x06008CCF RID: 36047 RVA: 0x00241CEC File Offset: 0x0023FEEC
			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: 0x17002FC8 RID: 12232
			// (get) Token: 0x06008CD0 RID: 36048 RVA: 0x00241D10 File Offset: 0x0023FF10
			// (set) Token: 0x06008CD1 RID: 36049 RVA: 0x00241D38 File Offset: 0x0023FF38
			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: 0x17002FC9 RID: 12233
			// (get) Token: 0x06008CD2 RID: 36050 RVA: 0x00241D5C File Offset: 0x0023FF5C
			// (set) Token: 0x06008CD3 RID: 36051 RVA: 0x00241D84 File Offset: 0x0023FF84
			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: 0x17002FCA RID: 12234
			// (get) Token: 0x06008CD4 RID: 36052 RVA: 0x00241DA8 File Offset: 0x0023FFA8
			// (set) Token: 0x06008CD5 RID: 36053 RVA: 0x00241DD0 File Offset: 0x0023FFD0
			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: 0x17002FCB RID: 12235
			// (get) Token: 0x06008CD6 RID: 36054 RVA: 0x00241DF4 File Offset: 0x0023FFF4
			// (set) Token: 0x06008CD7 RID: 36055 RVA: 0x00241E1C File Offset: 0x0024001C
			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: 0x17002FCC RID: 12236
			// (get) Token: 0x06008CD8 RID: 36056 RVA: 0x00241E40 File Offset: 0x00240040
			// (set) Token: 0x06008CD9 RID: 36057 RVA: 0x00241E68 File Offset: 0x00240068
			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: 0x17002FCD RID: 12237
			// (get) Token: 0x06008CDA RID: 36058 RVA: 0x00241E8C File Offset: 0x0024008C
			// (set) Token: 0x06008CDB RID: 36059 RVA: 0x00241EB4 File Offset: 0x002400B4
			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: 0x17002FCE RID: 12238
			// (get) Token: 0x06008CDC RID: 36060 RVA: 0x00241ED8 File Offset: 0x002400D8
			// (set) Token: 0x06008CDD RID: 36061 RVA: 0x00241F00 File Offset: 0x00240100
			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: 0x17002FCF RID: 12239
			// (get) Token: 0x06008CDE RID: 36062 RVA: 0x00241F24 File Offset: 0x00240124
			// (set) Token: 0x06008CDF RID: 36063 RVA: 0x00241F4C File Offset: 0x0024014C
			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: 0x17002FD0 RID: 12240
			// (get) Token: 0x06008CE0 RID: 36064 RVA: 0x00241F70 File Offset: 0x00240170
			// (set) Token: 0x06008CE1 RID: 36065 RVA: 0x00241F98 File Offset: 0x00240198
			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: 0x17002FD1 RID: 12241
			// (get) Token: 0x06008CE2 RID: 36066 RVA: 0x00241FBC File Offset: 0x002401BC
			// (set) Token: 0x06008CE3 RID: 36067 RVA: 0x00241FE4 File Offset: 0x002401E4
			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: 0x17002FD2 RID: 12242
			// (get) Token: 0x06008CE4 RID: 36068 RVA: 0x00242008 File Offset: 0x00240208
			// (set) Token: 0x06008CE5 RID: 36069 RVA: 0x00242030 File Offset: 0x00240230
			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: 0x17002FD3 RID: 12243
			// (get) Token: 0x06008CE6 RID: 36070 RVA: 0x00242054 File Offset: 0x00240254
			// (set) Token: 0x06008CE7 RID: 36071 RVA: 0x0024207C File Offset: 0x0024027C
			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: 0x17002FD4 RID: 12244
			// (get) Token: 0x06008CE8 RID: 36072 RVA: 0x002420A0 File Offset: 0x002402A0
			// (set) Token: 0x06008CE9 RID: 36073 RVA: 0x002420C8 File Offset: 0x002402C8
			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: 0x17002FD5 RID: 12245
			// (get) Token: 0x06008CEA RID: 36074 RVA: 0x002420EC File Offset: 0x002402EC
			// (set) Token: 0x06008CEB RID: 36075 RVA: 0x00242114 File Offset: 0x00240314
			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: 0x17002FD6 RID: 12246
			// (get) Token: 0x06008CEC RID: 36076 RVA: 0x00242138 File Offset: 0x00240338
			// (set) Token: 0x06008CED RID: 36077 RVA: 0x00242160 File Offset: 0x00240360
			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: 0x17002FD7 RID: 12247
			// (get) Token: 0x06008CEE RID: 36078 RVA: 0x00242184 File Offset: 0x00240384
			// (set) Token: 0x06008CEF RID: 36079 RVA: 0x002421AC File Offset: 0x002403AC
			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: 0x17002FD8 RID: 12248
			// (get) Token: 0x06008CF0 RID: 36080 RVA: 0x002421D0 File Offset: 0x002403D0
			// (set) Token: 0x06008CF1 RID: 36081 RVA: 0x002421F8 File Offset: 0x002403F8
			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: 0x17002FD9 RID: 12249
			// (get) Token: 0x06008CF2 RID: 36082 RVA: 0x0024221C File Offset: 0x0024041C
			// (set) Token: 0x06008CF3 RID: 36083 RVA: 0x00242244 File Offset: 0x00240444
			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: 0x17002FDA RID: 12250
			// (get) Token: 0x06008CF4 RID: 36084 RVA: 0x00242268 File Offset: 0x00240468
			// (set) Token: 0x06008CF5 RID: 36085 RVA: 0x00242290 File Offset: 0x00240490
			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: 0x17002FDB RID: 12251
			// (get) Token: 0x06008CF6 RID: 36086 RVA: 0x002422B4 File Offset: 0x002404B4
			// (set) Token: 0x06008CF7 RID: 36087 RVA: 0x002422DC File Offset: 0x002404DC
			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: 0x17002FDC RID: 12252
			// (get) Token: 0x06008CF8 RID: 36088 RVA: 0x00242300 File Offset: 0x00240500
			// (set) Token: 0x06008CF9 RID: 36089 RVA: 0x00242328 File Offset: 0x00240528
			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: 0x04005DF6 RID: 24054
			private static readonly IntPtr NativeFieldInfoPtr_headTarget;

			// Token: 0x04005DF7 RID: 24055
			private static readonly IntPtr NativeFieldInfoPtr_pelvisTarget;

			// Token: 0x04005DF8 RID: 24056
			private static readonly IntPtr NativeFieldInfoPtr_positionWeight;

			// Token: 0x04005DF9 RID: 24057
			private static readonly IntPtr NativeFieldInfoPtr_rotationWeight;

			// Token: 0x04005DFA RID: 24058
			private static readonly IntPtr NativeFieldInfoPtr_pelvisPositionWeight;

			// Token: 0x04005DFB RID: 24059
			private static readonly IntPtr NativeFieldInfoPtr_pelvisRotationWeight;

			// Token: 0x04005DFC RID: 24060
			private static readonly IntPtr NativeFieldInfoPtr_chestGoal;

			// Token: 0x04005DFD RID: 24061
			private static readonly IntPtr NativeFieldInfoPtr_chestGoalWeight;

			// Token: 0x04005DFE RID: 24062
			private static readonly IntPtr NativeFieldInfoPtr_minHeadHeight;

			// Token: 0x04005DFF RID: 24063
			private static readonly IntPtr NativeFieldInfoPtr_bodyPosStiffness;

			// Token: 0x04005E00 RID: 24064
			private static readonly IntPtr NativeFieldInfoPtr_bodyRotStiffness;

			// Token: 0x04005E01 RID: 24065
			private static readonly IntPtr NativeFieldInfoPtr_neckStiffness;

			// Token: 0x04005E02 RID: 24066
			private static readonly IntPtr NativeFieldInfoPtr_chestClampWeight;

			// Token: 0x04005E03 RID: 24067
			private static readonly IntPtr NativeFieldInfoPtr_headClampWeight;

			// Token: 0x04005E04 RID: 24068
			private static readonly IntPtr NativeFieldInfoPtr_maintainPelvisPosition;

			// Token: 0x04005E05 RID: 24069
			private static readonly IntPtr NativeFieldInfoPtr_maxRootAngle;

			// Token: 0x04005E06 RID: 24070
			private static readonly IntPtr NativeFieldInfoPtr_IKPositionHead;

			// Token: 0x04005E07 RID: 24071
			private static readonly IntPtr NativeFieldInfoPtr_IKRotationHead;

			// Token: 0x04005E08 RID: 24072
			private static readonly IntPtr NativeFieldInfoPtr_IKPositionPelvis;

			// Token: 0x04005E09 RID: 24073
			private static readonly IntPtr NativeFieldInfoPtr_IKRotationPelvis;

			// Token: 0x04005E0A RID: 24074
			private static readonly IntPtr NativeFieldInfoPtr_goalPositionChest;

			// Token: 0x04005E0B RID: 24075
			private static readonly IntPtr NativeFieldInfoPtr_pelvisPositionOffset;

			// Token: 0x04005E0C RID: 24076
			private static readonly IntPtr NativeFieldInfoPtr_chestPositionOffset;

			// Token: 0x04005E0D RID: 24077
			private static readonly IntPtr NativeFieldInfoPtr_headPositionOffset;

			// Token: 0x04005E0E RID: 24078
			private static readonly IntPtr NativeFieldInfoPtr_pelvisRotationOffset;

			// Token: 0x04005E0F RID: 24079
			private static readonly IntPtr NativeFieldInfoPtr_chestRotationOffset;

			// Token: 0x04005E10 RID: 24080
			private static readonly IntPtr NativeFieldInfoPtr_headRotationOffset;

			// Token: 0x04005E11 RID: 24081
			private static readonly IntPtr NativeFieldInfoPtr_faceDirection;

			// Token: 0x04005E12 RID: 24082
			private static readonly IntPtr NativeFieldInfoPtr_locomotionHeadPositionOffset;

			// Token: 0x04005E13 RID: 24083
			private static readonly IntPtr NativeFieldInfoPtr_headPosition;

			// Token: 0x04005E14 RID: 24084
			private static readonly IntPtr NativeFieldInfoPtr__anchorRotation_k__BackingField;

			// Token: 0x04005E15 RID: 24085
			private static readonly IntPtr NativeFieldInfoPtr_headRotation;

			// Token: 0x04005E16 RID: 24086
			private static readonly IntPtr NativeFieldInfoPtr_anchorRelativeToHead;

			// Token: 0x04005E17 RID: 24087
			private static readonly IntPtr NativeFieldInfoPtr_pelvisRelativeRotation;

			// Token: 0x04005E18 RID: 24088
			private static readonly IntPtr NativeFieldInfoPtr_chestRelativeRotation;

			// Token: 0x04005E19 RID: 24089
			private static readonly IntPtr NativeFieldInfoPtr_headDeltaPosition;

			// Token: 0x04005E1A RID: 24090
			private static readonly IntPtr NativeFieldInfoPtr_pelvisDeltaRotation;

			// Token: 0x04005E1B RID: 24091
			private static readonly IntPtr NativeFieldInfoPtr_chestTargetRotation;

			// Token: 0x04005E1C RID: 24092
			private static readonly IntPtr NativeFieldInfoPtr_pelvisIndex;

			// Token: 0x04005E1D RID: 24093
			private static readonly IntPtr NativeFieldInfoPtr_spineIndex;

			// Token: 0x04005E1E RID: 24094
			private static readonly IntPtr NativeFieldInfoPtr_chestIndex;

			// Token: 0x04005E1F RID: 24095
			private static readonly IntPtr NativeFieldInfoPtr_neckIndex;

			// Token: 0x04005E20 RID: 24096
			private static readonly IntPtr NativeFieldInfoPtr_headIndex;

			// Token: 0x04005E21 RID: 24097
			private static readonly IntPtr NativeFieldInfoPtr_length;

			// Token: 0x04005E22 RID: 24098
			private static readonly IntPtr NativeFieldInfoPtr_hasChest;

			// Token: 0x04005E23 RID: 24099
			private static readonly IntPtr NativeFieldInfoPtr_hasNeck;

			// Token: 0x04005E24 RID: 24100
			private static readonly IntPtr NativeFieldInfoPtr_headHeight;

			// Token: 0x04005E25 RID: 24101
			private static readonly IntPtr NativeFieldInfoPtr_sizeMlp;

			// Token: 0x04005E26 RID: 24102
			private static readonly IntPtr NativeFieldInfoPtr_chestForward;

			// Token: 0x04005E27 RID: 24103
			private static readonly IntPtr NativeMethodInfoPtr_get_pelvis_Public_get_VirtualBone_0;

			// Token: 0x04005E28 RID: 24104
			private static readonly IntPtr NativeMethodInfoPtr_get_firstSpineBone_Public_get_VirtualBone_0;

			// Token: 0x04005E29 RID: 24105
			private static readonly IntPtr NativeMethodInfoPtr_get_chest_Public_get_VirtualBone_0;

			// Token: 0x04005E2A RID: 24106
			private static readonly IntPtr NativeMethodInfoPtr_get_neck_Private_get_VirtualBone_0;

			// Token: 0x04005E2B RID: 24107
			private static readonly IntPtr NativeMethodInfoPtr_get_head_Public_get_VirtualBone_0;

			// Token: 0x04005E2C RID: 24108
			private static readonly IntPtr NativeMethodInfoPtr_get_anchorRotation_Public_get_Quaternion_0;

			// Token: 0x04005E2D RID: 24109
			private static readonly IntPtr NativeMethodInfoPtr_set_anchorRotation_Private_set_Void_Quaternion_0;

			// Token: 0x04005E2E RID: 24110
			private static readonly IntPtr NativeMethodInfoPtr_OnRead_Protected_Virtual_Void_Il2CppStructArray_1_Vector3_Il2CppStructArray_1_Quaternion_Boolean_Boolean_Boolean_Boolean_Int32_Int32_0;

			// Token: 0x04005E2F RID: 24111
			private static readonly IntPtr NativeMethodInfoPtr_PreSolve_Public_Virtual_Void_0;

			// Token: 0x04005E30 RID: 24112
			private static readonly IntPtr NativeMethodInfoPtr_ApplyOffsets_Public_Virtual_Void_0;

			// Token: 0x04005E31 RID: 24113
			private static readonly IntPtr NativeMethodInfoPtr_CalculateChestTargetRotation_Private_Void_VirtualBone_Il2CppReferenceArray_1_Arm_0;

			// Token: 0x04005E32 RID: 24114
			private static readonly IntPtr NativeMethodInfoPtr_Solve_Public_Void_VirtualBone_Il2CppReferenceArray_1_Leg_Il2CppReferenceArray_1_Arm_0;

			// Token: 0x04005E33 RID: 24115
			private static readonly IntPtr NativeMethodInfoPtr_SolvePelvis_Private_Void_0;

			// Token: 0x04005E34 RID: 24116
			private static readonly IntPtr NativeMethodInfoPtr_Write_Public_Virtual_Void_byref_Il2CppStructArray_1_Vector3_byref_Il2CppStructArray_1_Quaternion_0;

			// Token: 0x04005E35 RID: 24117
			private static readonly IntPtr NativeMethodInfoPtr_ResetOffsets_Public_Virtual_Void_0;

			// Token: 0x04005E36 RID: 24118
			private static readonly IntPtr NativeMethodInfoPtr_AdjustChestByHands_Private_Void_byref_Quaternion_Il2CppReferenceArray_1_Arm_0;

			// Token: 0x04005E37 RID: 24119
			private static readonly IntPtr NativeMethodInfoPtr_InverseTranslateToHead_Public_Void_Il2CppReferenceArray_1_Leg_Boolean_Boolean_Vector3_Single_0;

			// Token: 0x04005E38 RID: 24120
			private static readonly IntPtr NativeMethodInfoPtr_TranslatePelvis_Private_Void_Il2CppReferenceArray_1_Leg_Vector3_Quaternion_0;

			// Token: 0x04005E39 RID: 24121
			private static readonly IntPtr NativeMethodInfoPtr_LimitPelvisPosition_Private_Vector3_Il2CppReferenceArray_1_Leg_Vector3_Boolean_Int32_0;

			// Token: 0x04005E3A RID: 24122
			private static readonly IntPtr NativeMethodInfoPtr_Bend_Private_Void_Il2CppReferenceArray_1_VirtualBone_Int32_Int32_Quaternion_Single_Boolean_Single_0;

			// Token: 0x04005E3B RID: 24123
			private static readonly IntPtr NativeMethodInfoPtr_Bend_Private_Void_Il2CppReferenceArray_1_VirtualBone_Int32_Int32_Quaternion_Quaternion_Single_Boolean_Single_0;

			// Token: 0x04005E3C RID: 24124
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
		}

		// Token: 0x020004A8 RID: 1192
		[Serializable]
		public enum PositionOffset
		{
			// Token: 0x04005E3E RID: 24126
			Pelvis,
			// Token: 0x04005E3F RID: 24127
			Chest,
			// Token: 0x04005E40 RID: 24128
			Head,
			// Token: 0x04005E41 RID: 24129
			LeftHand,
			// Token: 0x04005E42 RID: 24130
			RightHand,
			// Token: 0x04005E43 RID: 24131
			LeftFoot,
			// Token: 0x04005E44 RID: 24132
			RightFoot,
			// Token: 0x04005E45 RID: 24133
			LeftHeel,
			// Token: 0x04005E46 RID: 24134
			RightHeel
		}

		// Token: 0x020004A9 RID: 1193
		[Serializable]
		public enum RotationOffset
		{
			// Token: 0x04005E48 RID: 24136
			Pelvis,
			// Token: 0x04005E49 RID: 24137
			Chest,
			// Token: 0x04005E4A RID: 24138
			Head
		}

		// Token: 0x020004AA RID: 1194
		[Serializable]
		public class VirtualBone : Il2CppSystem.Object
		{
			// Token: 0x06008CFA RID: 36090 RVA: 0x0024234C File Offset: 0x0024054C
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 633426, RefRangeEnd = 633427, XrefRangeStart = 633425, XrefRangeEnd = 633426, 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: 0x06008CFB RID: 36091 RVA: 0x002423BC File Offset: 0x002405BC
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 633427, RefRangeEnd = 633428, XrefRangeStart = 633427, XrefRangeEnd = 633427, 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: 0x06008CFC RID: 36092 RVA: 0x00242424 File Offset: 0x00240624
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 633434, RefRangeEnd = 633435, XrefRangeStart = 633428, XrefRangeEnd = 633434, 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: 0x06008CFD RID: 36093 RVA: 0x002424A8 File Offset: 0x002406A8
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 633442, RefRangeEnd = 633443, XrefRangeStart = 633435, XrefRangeEnd = 633442, 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: 0x06008CFE RID: 36094 RVA: 0x00242520 File Offset: 0x00240720
			[CallerCount(10)]
			[CachedScanResults(RefRangeStart = 633446, RefRangeEnd = 633456, XrefRangeStart = 633443, XrefRangeEnd = 633446, 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: 0x06008CFF RID: 36095 RVA: 0x002425A4 File Offset: 0x002407A4
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 633459, RefRangeEnd = 633460, XrefRangeStart = 633456, XrefRangeEnd = 633459, 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: 0x06008D00 RID: 36096 RVA: 0x00242614 File Offset: 0x00240814
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 633463, RefRangeEnd = 633465, XrefRangeStart = 633460, XrefRangeEnd = 633463, 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: 0x06008D01 RID: 36097 RVA: 0x00242674 File Offset: 0x00240874
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 633465, XrefRangeEnd = 633467, 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: 0x06008D02 RID: 36098 RVA: 0x002426E4 File Offset: 0x002408E4
			[CallerCount(11)]
			[CachedScanResults(RefRangeStart = 633494, RefRangeEnd = 633505, XrefRangeStart = 633467, XrefRangeEnd = 633494, 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: 0x06008D03 RID: 36099 RVA: 0x002427A0 File Offset: 0x002409A0
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 633505, XrefRangeEnd = 633517, 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: 0x06008D04 RID: 36100 RVA: 0x00242840 File Offset: 0x00240A40
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 633526, RefRangeEnd = 633528, XrefRangeStart = 633517, XrefRangeEnd = 633526, 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: 0x06008D05 RID: 36101 RVA: 0x002428FC File Offset: 0x00240AFC
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 633529, RefRangeEnd = 633531, XrefRangeStart = 633528, XrefRangeEnd = 633529, 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: 0x06008D06 RID: 36102 RVA: 0x00242978 File Offset: 0x00240B78
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 633531, XrefRangeEnd = 633535, 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: 0x06008D07 RID: 36103 RVA: 0x002429FC File Offset: 0x00240BFC
			// 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, 100674094);
				IKSolverVR.VirtualBone.NativeMethodInfoPtr_Read_Public_Void_Vector3_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, 100674095);
				IKSolverVR.VirtualBone.NativeMethodInfoPtr_SwingRotation_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Int32_Vector3_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, 100674096);
				IKSolverVR.VirtualBone.NativeMethodInfoPtr_PreSolve_Public_Static_Single_byref_Il2CppReferenceArray_1_VirtualBone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, 100674097);
				IKSolverVR.VirtualBone.NativeMethodInfoPtr_RotateAroundPoint_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Int32_Vector3_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, 100674098);
				IKSolverVR.VirtualBone.NativeMethodInfoPtr_RotateBy_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Int32_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, 100674099);
				IKSolverVR.VirtualBone.NativeMethodInfoPtr_RotateBy_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, 100674100);
				IKSolverVR.VirtualBone.NativeMethodInfoPtr_RotateTo_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Int32_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, 100674101);
				IKSolverVR.VirtualBone.NativeMethodInfoPtr_SolveTrigonometric_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Int32_Int32_Int32_Vector3_Vector3_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, 100674102);
				IKSolverVR.VirtualBone.NativeMethodInfoPtr_GetDirectionToBendPoint_Private_Static_Vector3_Vector3_Single_Vector3_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, 100674103);
				IKSolverVR.VirtualBone.NativeMethodInfoPtr_SolveFABRIK_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Vector3_Vector3_Single_Single_Int32_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, 100674104);
				IKSolverVR.VirtualBone.NativeMethodInfoPtr_SolveFABRIKJoint_Private_Static_Vector3_Vector3_Vector3_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, 100674105);
				IKSolverVR.VirtualBone.NativeMethodInfoPtr_SolveCCD_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Vector3_Single_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolverVR.VirtualBone>.NativeClassPtr, 100674106);
			}

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

			// Token: 0x17002FE3 RID: 12259
			// (get) Token: 0x06008D09 RID: 36105 RVA: 0x00242BB8 File Offset: 0x00240DB8
			// (set) Token: 0x06008D0A RID: 36106 RVA: 0x00242BE0 File Offset: 0x00240DE0
			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: 0x17002FE4 RID: 12260
			// (get) Token: 0x06008D0B RID: 36107 RVA: 0x00242C04 File Offset: 0x00240E04
			// (set) Token: 0x06008D0C RID: 36108 RVA: 0x00242C2C File Offset: 0x00240E2C
			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: 0x17002FE5 RID: 12261
			// (get) Token: 0x06008D0D RID: 36109 RVA: 0x00242C50 File Offset: 0x00240E50
			// (set) Token: 0x06008D0E RID: 36110 RVA: 0x00242C78 File Offset: 0x00240E78
			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: 0x17002FE6 RID: 12262
			// (get) Token: 0x06008D0F RID: 36111 RVA: 0x00242C9C File Offset: 0x00240E9C
			// (set) Token: 0x06008D10 RID: 36112 RVA: 0x00242CC4 File Offset: 0x00240EC4
			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: 0x17002FE7 RID: 12263
			// (get) Token: 0x06008D11 RID: 36113 RVA: 0x00242CE8 File Offset: 0x00240EE8
			// (set) Token: 0x06008D12 RID: 36114 RVA: 0x00242D10 File Offset: 0x00240F10
			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: 0x17002FE8 RID: 12264
			// (get) Token: 0x06008D13 RID: 36115 RVA: 0x00242D34 File Offset: 0x00240F34
			// (set) Token: 0x06008D14 RID: 36116 RVA: 0x00242D5C File Offset: 0x00240F5C
			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: 0x17002FE9 RID: 12265
			// (get) Token: 0x06008D15 RID: 36117 RVA: 0x00242D80 File Offset: 0x00240F80
			// (set) Token: 0x06008D16 RID: 36118 RVA: 0x00242DA8 File Offset: 0x00240FA8
			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: 0x04005E4B RID: 24139
			private static readonly IntPtr NativeFieldInfoPtr_readPosition;

			// Token: 0x04005E4C RID: 24140
			private static readonly IntPtr NativeFieldInfoPtr_readRotation;

			// Token: 0x04005E4D RID: 24141
			private static readonly IntPtr NativeFieldInfoPtr_solverPosition;

			// Token: 0x04005E4E RID: 24142
			private static readonly IntPtr NativeFieldInfoPtr_solverRotation;

			// Token: 0x04005E4F RID: 24143
			private static readonly IntPtr NativeFieldInfoPtr_length;

			// Token: 0x04005E50 RID: 24144
			private static readonly IntPtr NativeFieldInfoPtr_sqrMag;

			// Token: 0x04005E51 RID: 24145
			private static readonly IntPtr NativeFieldInfoPtr_axis;

			// Token: 0x04005E52 RID: 24146
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_Vector3_Quaternion_0;

			// Token: 0x04005E53 RID: 24147
			private static readonly IntPtr NativeMethodInfoPtr_Read_Public_Void_Vector3_Quaternion_0;

			// Token: 0x04005E54 RID: 24148
			private static readonly IntPtr NativeMethodInfoPtr_SwingRotation_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Int32_Vector3_Single_0;

			// Token: 0x04005E55 RID: 24149
			private static readonly IntPtr NativeMethodInfoPtr_PreSolve_Public_Static_Single_byref_Il2CppReferenceArray_1_VirtualBone_0;

			// Token: 0x04005E56 RID: 24150
			private static readonly IntPtr NativeMethodInfoPtr_RotateAroundPoint_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Int32_Vector3_Quaternion_0;

			// Token: 0x04005E57 RID: 24151
			private static readonly IntPtr NativeMethodInfoPtr_RotateBy_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Int32_Quaternion_0;

			// Token: 0x04005E58 RID: 24152
			private static readonly IntPtr NativeMethodInfoPtr_RotateBy_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Quaternion_0;

			// Token: 0x04005E59 RID: 24153
			private static readonly IntPtr NativeMethodInfoPtr_RotateTo_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Int32_Quaternion_0;

			// Token: 0x04005E5A RID: 24154
			private static readonly IntPtr NativeMethodInfoPtr_SolveTrigonometric_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Int32_Int32_Int32_Vector3_Vector3_Single_0;

			// Token: 0x04005E5B RID: 24155
			private static readonly IntPtr NativeMethodInfoPtr_GetDirectionToBendPoint_Private_Static_Vector3_Vector3_Single_Vector3_Single_Single_0;

			// Token: 0x04005E5C RID: 24156
			private static readonly IntPtr NativeMethodInfoPtr_SolveFABRIK_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Vector3_Vector3_Single_Single_Int32_Single_0;

			// Token: 0x04005E5D RID: 24157
			private static readonly IntPtr NativeMethodInfoPtr_SolveFABRIKJoint_Private_Static_Vector3_Vector3_Vector3_Single_0;

			// Token: 0x04005E5E RID: 24158
			private static readonly IntPtr NativeMethodInfoPtr_SolveCCD_Public_Static_Void_Il2CppReferenceArray_1_VirtualBone_Vector3_Single_Int32_0;
		}
	}
}
