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

namespace RootMotion.FinalIK
{
	// Token: 0x02000426 RID: 1062
	[Serializable]
	public class FBIKChain : Il2CppSystem.Object
	{
		// Token: 0x06007EEC RID: 32492 RVA: 0x00205350 File Offset: 0x00203550
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 596447, RefRangeEnd = 596448, XrefRangeStart = 596429, XrefRangeEnd = 596447, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe FBIKChain()
			: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr))
		{
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06007EED RID: 32493 RVA: 0x0020539C File Offset: 0x0020359C
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 596448, XrefRangeEnd = 596487, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe FBIKChain(float pin, float pull, Il2CppReferenceArray<Transform> nodeTransforms = null)
		{
			if (nodeTransforms == null)
			{
				nodeTransforms = new Il2CppReferenceArray<Transform>(0L);
			}
			this..ctor(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr));
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref pin;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref pull;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(nodeTransforms);
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.NativeMethodInfoPtr__ctor_Public_Void_Single_Single_Il2CppReferenceArray_1_Transform_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06007EEE RID: 32494 RVA: 0x0020543C File Offset: 0x0020363C
		[CallerCount(5)]
		[CachedScanResults(RefRangeStart = 596498, RefRangeEnd = 596503, XrefRangeStart = 596487, XrefRangeEnd = 596498, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void SetNodes(Il2CppReferenceArray<Transform> boneTransforms = null)
		{
			if (boneTransforms == null)
			{
				boneTransforms = new Il2CppReferenceArray<Transform>(0L);
			}
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(boneTransforms);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.NativeMethodInfoPtr_SetNodes_Public_Void_Il2CppReferenceArray_1_Transform_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}
		}

		// Token: 0x06007EEF RID: 32495 RVA: 0x002054AC File Offset: 0x002036AC
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 596508, RefRangeEnd = 596509, XrefRangeStart = 596503, XrefRangeEnd = 596508, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe int GetNodeIndex(Transform boneTransform)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(boneTransform);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.NativeMethodInfoPtr_GetNodeIndex_Public_Int32_Transform_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}
		}

		// Token: 0x06007EF0 RID: 32496 RVA: 0x00205514 File Offset: 0x00203714
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 596519, RefRangeEnd = 596520, XrefRangeStart = 596509, XrefRangeEnd = 596519, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe 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(FBIKChain.NativeMethodInfoPtr_IsValid_Public_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: 0x06007EF1 RID: 32497 RVA: 0x00205594 File Offset: 0x00203794
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 596531, RefRangeEnd = 596532, XrefRangeStart = 596520, XrefRangeEnd = 596531, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void Initiate(IKSolverFullBody solver)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(solver);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.NativeMethodInfoPtr_Initiate_Public_Void_IKSolverFullBody_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}
		}

		// Token: 0x06007EF2 RID: 32498 RVA: 0x002055F0 File Offset: 0x002037F0
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 596547, RefRangeEnd = 596548, XrefRangeStart = 596532, XrefRangeEnd = 596547, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void ReadPose(IKSolverFullBody solver, bool fullBody)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(solver);
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref fullBody;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.NativeMethodInfoPtr_ReadPose_Public_Void_IKSolverFullBody_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06007EF3 RID: 32499 RVA: 0x0020565C File Offset: 0x0020385C
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 596578, RefRangeEnd = 596580, XrefRangeStart = 596548, XrefRangeEnd = 596578, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void CalculateBoneLengths(IKSolverFullBody solver)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(solver);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.NativeMethodInfoPtr_CalculateBoneLengths_Private_Void_IKSolverFullBody_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}
		}

		// Token: 0x06007EF4 RID: 32500 RVA: 0x002056B8 File Offset: 0x002038B8
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 596589, RefRangeEnd = 596591, XrefRangeStart = 596580, XrefRangeEnd = 596589, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void Reach(IKSolverFullBody solver)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(solver);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.NativeMethodInfoPtr_Reach_Public_Void_IKSolverFullBody_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}
		}

		// Token: 0x06007EF5 RID: 32501 RVA: 0x00205714 File Offset: 0x00203914
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 596596, RefRangeEnd = 596598, XrefRangeStart = 596591, XrefRangeEnd = 596596, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe Vector3 Push(IKSolverFullBody solver)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(solver);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.NativeMethodInfoPtr_Push_Public_Vector3_IKSolverFullBody_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}
		}

		// Token: 0x06007EF6 RID: 32502 RVA: 0x0020577C File Offset: 0x0020397C
		[CallerCount(4)]
		[CachedScanResults(RefRangeStart = 596616, RefRangeEnd = 596620, XrefRangeStart = 596598, XrefRangeEnd = 596616, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void SolveTrigonometric(IKSolverFullBody solver, bool calculateBendDirection = false)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(solver);
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref calculateBendDirection;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.NativeMethodInfoPtr_SolveTrigonometric_Public_Void_IKSolverFullBody_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06007EF7 RID: 32503 RVA: 0x002057E8 File Offset: 0x002039E8
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 596629, RefRangeEnd = 596631, XrefRangeStart = 596620, XrefRangeEnd = 596629, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void Stage1(IKSolverFullBody solver)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(solver);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.NativeMethodInfoPtr_Stage1_Public_Void_IKSolverFullBody_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}
		}

		// Token: 0x06007EF8 RID: 32504 RVA: 0x00205844 File Offset: 0x00203A44
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 596636, RefRangeEnd = 596638, XrefRangeStart = 596631, XrefRangeEnd = 596636, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void Stage2(IKSolverFullBody solver, Vector3 position)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(solver);
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref position;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.NativeMethodInfoPtr_Stage2_Public_Void_IKSolverFullBody_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06007EF9 RID: 32505 RVA: 0x002058B0 File Offset: 0x00203AB0
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 596641, RefRangeEnd = 596642, XrefRangeStart = 596638, XrefRangeEnd = 596641, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void SolveConstraintSystems(IKSolverFullBody solver)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(solver);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.NativeMethodInfoPtr_SolveConstraintSystems_Public_Void_IKSolverFullBody_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}
		}

		// Token: 0x06007EFA RID: 32506 RVA: 0x0020590C File Offset: 0x00203B0C
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 596643, RefRangeEnd = 596644, XrefRangeStart = 596642, XrefRangeEnd = 596643, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe Vector3 SolveFABRIKJoint(Vector3 pos1, Vector3 pos2, float length)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			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(FBIKChain.NativeMethodInfoPtr_SolveFABRIKJoint_Private_Vector3_Vector3_Vector3_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x06007EFB RID: 32507 RVA: 0x00205994 File Offset: 0x00203B94
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 596644, XrefRangeEnd = 596656, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe Vector3 GetDirToBendPoint(Vector3 direction, Vector3 bendDirection, float directionMagnitude)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref direction;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref bendDirection;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref directionMagnitude;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.NativeMethodInfoPtr_GetDirToBendPoint_Protected_Vector3_Vector3_Vector3_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x06007EFC RID: 32508 RVA: 0x00205A1C File Offset: 0x00203C1C
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 596658, RefRangeEnd = 596659, XrefRangeStart = 596656, XrefRangeEnd = 596658, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void SolveChildConstraints(IKSolverFullBody solver)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(solver);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.NativeMethodInfoPtr_SolveChildConstraints_Private_Void_IKSolverFullBody_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}
		}

		// Token: 0x06007EFD RID: 32509 RVA: 0x00205A78 File Offset: 0x00203C78
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 596659, XrefRangeEnd = 596660, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void SolveLinearConstraint(IKSolver.Node node1, IKSolver.Node node2, float crossFade, float distance)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(node1);
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(node2);
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref crossFade;
			ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref distance;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.NativeMethodInfoPtr_SolveLinearConstraint_Private_Void_Node_Node_Single_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06007EFE RID: 32510 RVA: 0x00205B10 File Offset: 0x00203D10
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 596661, RefRangeEnd = 596662, XrefRangeStart = 596660, XrefRangeEnd = 596661, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void ForwardReach(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(FBIKChain.NativeMethodInfoPtr_ForwardReach_Public_Void_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}
		}

		// Token: 0x06007EFF RID: 32511 RVA: 0x00205B64 File Offset: 0x00203D64
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 596665, RefRangeEnd = 596666, XrefRangeStart = 596662, XrefRangeEnd = 596665, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void BackwardReach(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(FBIKChain.NativeMethodInfoPtr_BackwardReach_Private_Void_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}
		}

		// Token: 0x06007F00 RID: 32512 RVA: 0x00205BB8 File Offset: 0x00203DB8
		public FBIKChain(float pin, float pull, params Transform[] nodeTransforms)
			: this(pin, pull, new Il2CppReferenceArray<Transform>(nodeTransforms))
		{
		}

		// Token: 0x06007F01 RID: 32513 RVA: 0x00205BD1 File Offset: 0x00203DD1
		public void SetNodes(params Transform[] boneTransforms)
		{
			this.SetNodes(new Il2CppReferenceArray<Transform>(boneTransforms));
		}

		// Token: 0x06007F02 RID: 32514 RVA: 0x00205BE4 File Offset: 0x00203DE4
		// Note: this type is marked as 'beforefieldinit'.
		static FBIKChain()
		{
			Il2CppClassPointerStore<FBIKChain>.NativeClassPtr = IL2CPP.GetIl2CppClass("Assembly-CSharp.dll", "RootMotion.FinalIK", "FBIKChain");
			IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr);
			FBIKChain.NativeFieldInfoPtr_pin = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "pin");
			FBIKChain.NativeFieldInfoPtr_pull = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "pull");
			FBIKChain.NativeFieldInfoPtr_push = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "push");
			FBIKChain.NativeFieldInfoPtr_pushParent = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "pushParent");
			FBIKChain.NativeFieldInfoPtr_reach = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "reach");
			FBIKChain.NativeFieldInfoPtr_reachSmoothing = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "reachSmoothing");
			FBIKChain.NativeFieldInfoPtr_pushSmoothing = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "pushSmoothing");
			FBIKChain.NativeFieldInfoPtr_nodes = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "nodes");
			FBIKChain.NativeFieldInfoPtr_children = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "children");
			FBIKChain.NativeFieldInfoPtr_childConstraints = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "childConstraints");
			FBIKChain.NativeFieldInfoPtr_bendConstraint = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "bendConstraint");
			FBIKChain.NativeFieldInfoPtr_rootLength = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "rootLength");
			FBIKChain.NativeFieldInfoPtr_initiated = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "initiated");
			FBIKChain.NativeFieldInfoPtr_length = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "length");
			FBIKChain.NativeFieldInfoPtr_distance = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "distance");
			FBIKChain.NativeFieldInfoPtr_p = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "p");
			FBIKChain.NativeFieldInfoPtr_reachForce = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "reachForce");
			FBIKChain.NativeFieldInfoPtr_pullParentSum = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "pullParentSum");
			FBIKChain.NativeFieldInfoPtr_crossFades = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "crossFades");
			FBIKChain.NativeFieldInfoPtr_sqrMag1 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "sqrMag1");
			FBIKChain.NativeFieldInfoPtr_sqrMag2 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "sqrMag2");
			FBIKChain.NativeFieldInfoPtr_sqrMagDif = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "sqrMagDif");
			FBIKChain.NativeFieldInfoPtr_maxLimbLength = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "maxLimbLength");
			FBIKChain.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, 100672866);
			FBIKChain.NativeMethodInfoPtr__ctor_Public_Void_Single_Single_Il2CppReferenceArray_1_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, 100672867);
			FBIKChain.NativeMethodInfoPtr_SetNodes_Public_Void_Il2CppReferenceArray_1_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, 100672868);
			FBIKChain.NativeMethodInfoPtr_GetNodeIndex_Public_Int32_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, 100672869);
			FBIKChain.NativeMethodInfoPtr_IsValid_Public_Boolean_byref_String_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, 100672870);
			FBIKChain.NativeMethodInfoPtr_Initiate_Public_Void_IKSolverFullBody_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, 100672871);
			FBIKChain.NativeMethodInfoPtr_ReadPose_Public_Void_IKSolverFullBody_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, 100672872);
			FBIKChain.NativeMethodInfoPtr_CalculateBoneLengths_Private_Void_IKSolverFullBody_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, 100672873);
			FBIKChain.NativeMethodInfoPtr_Reach_Public_Void_IKSolverFullBody_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, 100672874);
			FBIKChain.NativeMethodInfoPtr_Push_Public_Vector3_IKSolverFullBody_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, 100672875);
			FBIKChain.NativeMethodInfoPtr_SolveTrigonometric_Public_Void_IKSolverFullBody_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, 100672876);
			FBIKChain.NativeMethodInfoPtr_Stage1_Public_Void_IKSolverFullBody_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, 100672877);
			FBIKChain.NativeMethodInfoPtr_Stage2_Public_Void_IKSolverFullBody_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, 100672878);
			FBIKChain.NativeMethodInfoPtr_SolveConstraintSystems_Public_Void_IKSolverFullBody_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, 100672879);
			FBIKChain.NativeMethodInfoPtr_SolveFABRIKJoint_Private_Vector3_Vector3_Vector3_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, 100672880);
			FBIKChain.NativeMethodInfoPtr_GetDirToBendPoint_Protected_Vector3_Vector3_Vector3_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, 100672881);
			FBIKChain.NativeMethodInfoPtr_SolveChildConstraints_Private_Void_IKSolverFullBody_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, 100672882);
			FBIKChain.NativeMethodInfoPtr_SolveLinearConstraint_Private_Void_Node_Node_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, 100672883);
			FBIKChain.NativeMethodInfoPtr_ForwardReach_Public_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, 100672884);
			FBIKChain.NativeMethodInfoPtr_BackwardReach_Private_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, 100672885);
		}

		// Token: 0x06007F03 RID: 32515 RVA: 0x0000A688 File Offset: 0x00008888
		public FBIKChain(IntPtr pointer)
			: base(pointer)
		{
		}

		// Token: 0x17002B47 RID: 11079
		// (get) Token: 0x06007F04 RID: 32516 RVA: 0x00205F70 File Offset: 0x00204170
		// (set) Token: 0x06007F05 RID: 32517 RVA: 0x00205F98 File Offset: 0x00204198
		public unsafe float pin
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_pin);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_pin)) = value;
			}
		}

		// Token: 0x17002B48 RID: 11080
		// (get) Token: 0x06007F06 RID: 32518 RVA: 0x00205FBC File Offset: 0x002041BC
		// (set) Token: 0x06007F07 RID: 32519 RVA: 0x00205FE4 File Offset: 0x002041E4
		public unsafe float pull
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_pull);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_pull)) = value;
			}
		}

		// Token: 0x17002B49 RID: 11081
		// (get) Token: 0x06007F08 RID: 32520 RVA: 0x00206008 File Offset: 0x00204208
		// (set) Token: 0x06007F09 RID: 32521 RVA: 0x00206030 File Offset: 0x00204230
		public unsafe float push
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_push);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_push)) = value;
			}
		}

		// Token: 0x17002B4A RID: 11082
		// (get) Token: 0x06007F0A RID: 32522 RVA: 0x00206054 File Offset: 0x00204254
		// (set) Token: 0x06007F0B RID: 32523 RVA: 0x0020607C File Offset: 0x0020427C
		public unsafe float pushParent
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_pushParent);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_pushParent)) = value;
			}
		}

		// Token: 0x17002B4B RID: 11083
		// (get) Token: 0x06007F0C RID: 32524 RVA: 0x002060A0 File Offset: 0x002042A0
		// (set) Token: 0x06007F0D RID: 32525 RVA: 0x002060C8 File Offset: 0x002042C8
		public unsafe float reach
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_reach);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_reach)) = value;
			}
		}

		// Token: 0x17002B4C RID: 11084
		// (get) Token: 0x06007F0E RID: 32526 RVA: 0x002060EC File Offset: 0x002042EC
		// (set) Token: 0x06007F0F RID: 32527 RVA: 0x00206114 File Offset: 0x00204314
		public unsafe FBIKChain.Smoothing reachSmoothing
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_reachSmoothing);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_reachSmoothing)) = value;
			}
		}

		// Token: 0x17002B4D RID: 11085
		// (get) Token: 0x06007F10 RID: 32528 RVA: 0x00206138 File Offset: 0x00204338
		// (set) Token: 0x06007F11 RID: 32529 RVA: 0x00206160 File Offset: 0x00204360
		public unsafe FBIKChain.Smoothing pushSmoothing
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_pushSmoothing);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_pushSmoothing)) = value;
			}
		}

		// Token: 0x17002B4E RID: 11086
		// (get) Token: 0x06007F12 RID: 32530 RVA: 0x00206184 File Offset: 0x00204384
		// (set) Token: 0x06007F13 RID: 32531 RVA: 0x002061B8 File Offset: 0x002043B8
		public unsafe Il2CppReferenceArray<IKSolver.Node> nodes
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_nodes);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new Il2CppReferenceArray<IKSolver.Node>(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_nodes), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002B4F RID: 11087
		// (get) Token: 0x06007F14 RID: 32532 RVA: 0x002061E0 File Offset: 0x002043E0
		// (set) Token: 0x06007F15 RID: 32533 RVA: 0x00206214 File Offset: 0x00204414
		public unsafe Il2CppStructArray<int> children
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_children);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new Il2CppStructArray<int>(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_children), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002B50 RID: 11088
		// (get) Token: 0x06007F16 RID: 32534 RVA: 0x0020623C File Offset: 0x0020443C
		// (set) Token: 0x06007F17 RID: 32535 RVA: 0x00206270 File Offset: 0x00204470
		public unsafe Il2CppReferenceArray<FBIKChain.ChildConstraint> childConstraints
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_childConstraints);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new Il2CppReferenceArray<FBIKChain.ChildConstraint>(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_childConstraints), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002B51 RID: 11089
		// (get) Token: 0x06007F18 RID: 32536 RVA: 0x00206298 File Offset: 0x00204498
		// (set) Token: 0x06007F19 RID: 32537 RVA: 0x002062CC File Offset: 0x002044CC
		public unsafe IKConstraintBend bendConstraint
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_bendConstraint);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new IKConstraintBend(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_bendConstraint), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002B52 RID: 11090
		// (get) Token: 0x06007F1A RID: 32538 RVA: 0x002062F4 File Offset: 0x002044F4
		// (set) Token: 0x06007F1B RID: 32539 RVA: 0x0020631C File Offset: 0x0020451C
		public unsafe float rootLength
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_rootLength);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_rootLength)) = value;
			}
		}

		// Token: 0x17002B53 RID: 11091
		// (get) Token: 0x06007F1C RID: 32540 RVA: 0x00206340 File Offset: 0x00204540
		// (set) Token: 0x06007F1D RID: 32541 RVA: 0x00206368 File Offset: 0x00204568
		public unsafe bool initiated
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_initiated);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_initiated)) = value;
			}
		}

		// Token: 0x17002B54 RID: 11092
		// (get) Token: 0x06007F1E RID: 32542 RVA: 0x0020638C File Offset: 0x0020458C
		// (set) Token: 0x06007F1F RID: 32543 RVA: 0x002063B4 File Offset: 0x002045B4
		public unsafe float length
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_length);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_length)) = value;
			}
		}

		// Token: 0x17002B55 RID: 11093
		// (get) Token: 0x06007F20 RID: 32544 RVA: 0x002063D8 File Offset: 0x002045D8
		// (set) Token: 0x06007F21 RID: 32545 RVA: 0x00206400 File Offset: 0x00204600
		public unsafe float distance
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_distance);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_distance)) = value;
			}
		}

		// Token: 0x17002B56 RID: 11094
		// (get) Token: 0x06007F22 RID: 32546 RVA: 0x00206424 File Offset: 0x00204624
		// (set) Token: 0x06007F23 RID: 32547 RVA: 0x00206458 File Offset: 0x00204658
		public unsafe IKSolver.Point p
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_p);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new IKSolver.Point(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_p), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002B57 RID: 11095
		// (get) Token: 0x06007F24 RID: 32548 RVA: 0x00206480 File Offset: 0x00204680
		// (set) Token: 0x06007F25 RID: 32549 RVA: 0x002064A8 File Offset: 0x002046A8
		public unsafe float reachForce
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_reachForce);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_reachForce)) = value;
			}
		}

		// Token: 0x17002B58 RID: 11096
		// (get) Token: 0x06007F26 RID: 32550 RVA: 0x002064CC File Offset: 0x002046CC
		// (set) Token: 0x06007F27 RID: 32551 RVA: 0x002064F4 File Offset: 0x002046F4
		public unsafe float pullParentSum
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_pullParentSum);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_pullParentSum)) = value;
			}
		}

		// Token: 0x17002B59 RID: 11097
		// (get) Token: 0x06007F28 RID: 32552 RVA: 0x00206518 File Offset: 0x00204718
		// (set) Token: 0x06007F29 RID: 32553 RVA: 0x0020654C File Offset: 0x0020474C
		public unsafe Il2CppStructArray<float> crossFades
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_crossFades);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new Il2CppStructArray<float>(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_crossFades), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002B5A RID: 11098
		// (get) Token: 0x06007F2A RID: 32554 RVA: 0x00206574 File Offset: 0x00204774
		// (set) Token: 0x06007F2B RID: 32555 RVA: 0x0020659C File Offset: 0x0020479C
		public unsafe float sqrMag1
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_sqrMag1);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_sqrMag1)) = value;
			}
		}

		// Token: 0x17002B5B RID: 11099
		// (get) Token: 0x06007F2C RID: 32556 RVA: 0x002065C0 File Offset: 0x002047C0
		// (set) Token: 0x06007F2D RID: 32557 RVA: 0x002065E8 File Offset: 0x002047E8
		public unsafe float sqrMag2
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_sqrMag2);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_sqrMag2)) = value;
			}
		}

		// Token: 0x17002B5C RID: 11100
		// (get) Token: 0x06007F2E RID: 32558 RVA: 0x0020660C File Offset: 0x0020480C
		// (set) Token: 0x06007F2F RID: 32559 RVA: 0x00206634 File Offset: 0x00204834
		public unsafe float sqrMagDif
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_sqrMagDif);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.NativeFieldInfoPtr_sqrMagDif)) = value;
			}
		}

		// Token: 0x17002B5D RID: 11101
		// (get) Token: 0x06007F30 RID: 32560 RVA: 0x00206658 File Offset: 0x00204858
		// (set) Token: 0x06007F31 RID: 32561 RVA: 0x00206676 File Offset: 0x00204876
		public unsafe static float maxLimbLength
		{
			get
			{
				float num;
				IL2CPP.il2cpp_field_static_get_value(FBIKChain.NativeFieldInfoPtr_maxLimbLength, (void*)(&num));
				return num;
			}
			set
			{
				IL2CPP.il2cpp_field_static_set_value(FBIKChain.NativeFieldInfoPtr_maxLimbLength, (void*)(&value));
			}
		}

		// Token: 0x040054B6 RID: 21686
		private static readonly IntPtr NativeFieldInfoPtr_pin;

		// Token: 0x040054B7 RID: 21687
		private static readonly IntPtr NativeFieldInfoPtr_pull;

		// Token: 0x040054B8 RID: 21688
		private static readonly IntPtr NativeFieldInfoPtr_push;

		// Token: 0x040054B9 RID: 21689
		private static readonly IntPtr NativeFieldInfoPtr_pushParent;

		// Token: 0x040054BA RID: 21690
		private static readonly IntPtr NativeFieldInfoPtr_reach;

		// Token: 0x040054BB RID: 21691
		private static readonly IntPtr NativeFieldInfoPtr_reachSmoothing;

		// Token: 0x040054BC RID: 21692
		private static readonly IntPtr NativeFieldInfoPtr_pushSmoothing;

		// Token: 0x040054BD RID: 21693
		private static readonly IntPtr NativeFieldInfoPtr_nodes;

		// Token: 0x040054BE RID: 21694
		private static readonly IntPtr NativeFieldInfoPtr_children;

		// Token: 0x040054BF RID: 21695
		private static readonly IntPtr NativeFieldInfoPtr_childConstraints;

		// Token: 0x040054C0 RID: 21696
		private static readonly IntPtr NativeFieldInfoPtr_bendConstraint;

		// Token: 0x040054C1 RID: 21697
		private static readonly IntPtr NativeFieldInfoPtr_rootLength;

		// Token: 0x040054C2 RID: 21698
		private static readonly IntPtr NativeFieldInfoPtr_initiated;

		// Token: 0x040054C3 RID: 21699
		private static readonly IntPtr NativeFieldInfoPtr_length;

		// Token: 0x040054C4 RID: 21700
		private static readonly IntPtr NativeFieldInfoPtr_distance;

		// Token: 0x040054C5 RID: 21701
		private static readonly IntPtr NativeFieldInfoPtr_p;

		// Token: 0x040054C6 RID: 21702
		private static readonly IntPtr NativeFieldInfoPtr_reachForce;

		// Token: 0x040054C7 RID: 21703
		private static readonly IntPtr NativeFieldInfoPtr_pullParentSum;

		// Token: 0x040054C8 RID: 21704
		private static readonly IntPtr NativeFieldInfoPtr_crossFades;

		// Token: 0x040054C9 RID: 21705
		private static readonly IntPtr NativeFieldInfoPtr_sqrMag1;

		// Token: 0x040054CA RID: 21706
		private static readonly IntPtr NativeFieldInfoPtr_sqrMag2;

		// Token: 0x040054CB RID: 21707
		private static readonly IntPtr NativeFieldInfoPtr_sqrMagDif;

		// Token: 0x040054CC RID: 21708
		private static readonly IntPtr NativeFieldInfoPtr_maxLimbLength;

		// Token: 0x040054CD RID: 21709
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

		// Token: 0x040054CE RID: 21710
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_Single_Single_Il2CppReferenceArray_1_Transform_0;

		// Token: 0x040054CF RID: 21711
		private static readonly IntPtr NativeMethodInfoPtr_SetNodes_Public_Void_Il2CppReferenceArray_1_Transform_0;

		// Token: 0x040054D0 RID: 21712
		private static readonly IntPtr NativeMethodInfoPtr_GetNodeIndex_Public_Int32_Transform_0;

		// Token: 0x040054D1 RID: 21713
		private static readonly IntPtr NativeMethodInfoPtr_IsValid_Public_Boolean_byref_String_0;

		// Token: 0x040054D2 RID: 21714
		private static readonly IntPtr NativeMethodInfoPtr_Initiate_Public_Void_IKSolverFullBody_0;

		// Token: 0x040054D3 RID: 21715
		private static readonly IntPtr NativeMethodInfoPtr_ReadPose_Public_Void_IKSolverFullBody_Boolean_0;

		// Token: 0x040054D4 RID: 21716
		private static readonly IntPtr NativeMethodInfoPtr_CalculateBoneLengths_Private_Void_IKSolverFullBody_0;

		// Token: 0x040054D5 RID: 21717
		private static readonly IntPtr NativeMethodInfoPtr_Reach_Public_Void_IKSolverFullBody_0;

		// Token: 0x040054D6 RID: 21718
		private static readonly IntPtr NativeMethodInfoPtr_Push_Public_Vector3_IKSolverFullBody_0;

		// Token: 0x040054D7 RID: 21719
		private static readonly IntPtr NativeMethodInfoPtr_SolveTrigonometric_Public_Void_IKSolverFullBody_Boolean_0;

		// Token: 0x040054D8 RID: 21720
		private static readonly IntPtr NativeMethodInfoPtr_Stage1_Public_Void_IKSolverFullBody_0;

		// Token: 0x040054D9 RID: 21721
		private static readonly IntPtr NativeMethodInfoPtr_Stage2_Public_Void_IKSolverFullBody_Vector3_0;

		// Token: 0x040054DA RID: 21722
		private static readonly IntPtr NativeMethodInfoPtr_SolveConstraintSystems_Public_Void_IKSolverFullBody_0;

		// Token: 0x040054DB RID: 21723
		private static readonly IntPtr NativeMethodInfoPtr_SolveFABRIKJoint_Private_Vector3_Vector3_Vector3_Single_0;

		// Token: 0x040054DC RID: 21724
		private static readonly IntPtr NativeMethodInfoPtr_GetDirToBendPoint_Protected_Vector3_Vector3_Vector3_Single_0;

		// Token: 0x040054DD RID: 21725
		private static readonly IntPtr NativeMethodInfoPtr_SolveChildConstraints_Private_Void_IKSolverFullBody_0;

		// Token: 0x040054DE RID: 21726
		private static readonly IntPtr NativeMethodInfoPtr_SolveLinearConstraint_Private_Void_Node_Node_Single_Single_0;

		// Token: 0x040054DF RID: 21727
		private static readonly IntPtr NativeMethodInfoPtr_ForwardReach_Public_Void_Vector3_0;

		// Token: 0x040054E0 RID: 21728
		private static readonly IntPtr NativeMethodInfoPtr_BackwardReach_Private_Void_Vector3_0;

		// Token: 0x02000427 RID: 1063
		[Serializable]
		public class ChildConstraint : Il2CppSystem.Object
		{
			// Token: 0x17002B68 RID: 11112
			// (get) Token: 0x06007F32 RID: 32562 RVA: 0x00206688 File Offset: 0x00204888
			// (set) Token: 0x06007F33 RID: 32563 RVA: 0x002066D8 File Offset: 0x002048D8
			public unsafe float nominalDistance
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.ChildConstraint.NativeMethodInfoPtr_get_nominalDistance_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
				[CallerCount(2)]
				[CachedScanResults(RefRangeStart = 218210, RefRangeEnd = 218212, XrefRangeStart = 218210, XrefRangeEnd = 218212, 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(FBIKChain.ChildConstraint.NativeMethodInfoPtr_set_nominalDistance_Private_set_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
						Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					}
				}
			}

			// Token: 0x17002B69 RID: 11113
			// (get) Token: 0x06007F34 RID: 32564 RVA: 0x0020672C File Offset: 0x0020492C
			// (set) Token: 0x06007F35 RID: 32565 RVA: 0x0020677C File Offset: 0x0020497C
			public unsafe bool isRigid
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.ChildConstraint.NativeMethodInfoPtr_get_isRigid_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(FBIKChain.ChildConstraint.NativeMethodInfoPtr_set_isRigid_Private_set_Void_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
						Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					}
				}
			}

			// Token: 0x06007F36 RID: 32566 RVA: 0x002067D0 File Offset: 0x002049D0
			[CallerCount(4)]
			[CachedScanResults(RefRangeStart = 596409, RefRangeEnd = 596413, XrefRangeStart = 596406, XrefRangeEnd = 596409, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe ChildConstraint(Transform bone1, Transform bone2, float pushElasticity = 0f, float pullElasticity = 0f)
				: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<FBIKChain.ChildConstraint>.NativeClassPtr))
			{
				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)] = ref pushElasticity;
				ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref pullElasticity;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.ChildConstraint.NativeMethodInfoPtr__ctor_Public_Void_Transform_Transform_Single_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06007F37 RID: 32567 RVA: 0x00206870 File Offset: 0x00204A70
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 596417, RefRangeEnd = 596418, XrefRangeStart = 596413, XrefRangeEnd = 596417, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void Initiate(IKSolverFullBody solver)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				checked
				{
					IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(solver);
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.ChildConstraint.NativeMethodInfoPtr_Initiate_Public_Void_IKSolverFullBody_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				}
			}

			// Token: 0x06007F38 RID: 32568 RVA: 0x002068CC File Offset: 0x00204ACC
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 596423, RefRangeEnd = 596425, XrefRangeStart = 596418, XrefRangeEnd = 596423, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void OnPreSolve(IKSolverFullBody solver)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				checked
				{
					IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(solver);
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.ChildConstraint.NativeMethodInfoPtr_OnPreSolve_Public_Void_IKSolverFullBody_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				}
			}

			// Token: 0x06007F39 RID: 32569 RVA: 0x00206928 File Offset: 0x00204B28
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 596427, RefRangeEnd = 596429, XrefRangeStart = 596425, XrefRangeEnd = 596427, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void Solve(IKSolverFullBody solver)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				checked
				{
					IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(solver);
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(FBIKChain.ChildConstraint.NativeMethodInfoPtr_Solve_Public_Void_IKSolverFullBody_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				}
			}

			// Token: 0x06007F3A RID: 32570 RVA: 0x00206984 File Offset: 0x00204B84
			// Note: this type is marked as 'beforefieldinit'.
			static ChildConstraint()
			{
				Il2CppClassPointerStore<FBIKChain.ChildConstraint>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<FBIKChain>.NativeClassPtr, "ChildConstraint");
				IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<FBIKChain.ChildConstraint>.NativeClassPtr);
				FBIKChain.ChildConstraint.NativeFieldInfoPtr_pushElasticity = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain.ChildConstraint>.NativeClassPtr, "pushElasticity");
				FBIKChain.ChildConstraint.NativeFieldInfoPtr_pullElasticity = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain.ChildConstraint>.NativeClassPtr, "pullElasticity");
				FBIKChain.ChildConstraint.NativeFieldInfoPtr_bone1 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain.ChildConstraint>.NativeClassPtr, "bone1");
				FBIKChain.ChildConstraint.NativeFieldInfoPtr_bone2 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain.ChildConstraint>.NativeClassPtr, "bone2");
				FBIKChain.ChildConstraint.NativeFieldInfoPtr__nominalDistance_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain.ChildConstraint>.NativeClassPtr, "<nominalDistance>k__BackingField");
				FBIKChain.ChildConstraint.NativeFieldInfoPtr__isRigid_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain.ChildConstraint>.NativeClassPtr, "<isRigid>k__BackingField");
				FBIKChain.ChildConstraint.NativeFieldInfoPtr_crossFade = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain.ChildConstraint>.NativeClassPtr, "crossFade");
				FBIKChain.ChildConstraint.NativeFieldInfoPtr_inverseCrossFade = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain.ChildConstraint>.NativeClassPtr, "inverseCrossFade");
				FBIKChain.ChildConstraint.NativeFieldInfoPtr_chain1Index = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain.ChildConstraint>.NativeClassPtr, "chain1Index");
				FBIKChain.ChildConstraint.NativeFieldInfoPtr_chain2Index = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<FBIKChain.ChildConstraint>.NativeClassPtr, "chain2Index");
				FBIKChain.ChildConstraint.NativeMethodInfoPtr_get_nominalDistance_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain.ChildConstraint>.NativeClassPtr, 100672886);
				FBIKChain.ChildConstraint.NativeMethodInfoPtr_set_nominalDistance_Private_set_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain.ChildConstraint>.NativeClassPtr, 100672887);
				FBIKChain.ChildConstraint.NativeMethodInfoPtr_get_isRigid_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain.ChildConstraint>.NativeClassPtr, 100672888);
				FBIKChain.ChildConstraint.NativeMethodInfoPtr_set_isRigid_Private_set_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain.ChildConstraint>.NativeClassPtr, 100672889);
				FBIKChain.ChildConstraint.NativeMethodInfoPtr__ctor_Public_Void_Transform_Transform_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain.ChildConstraint>.NativeClassPtr, 100672890);
				FBIKChain.ChildConstraint.NativeMethodInfoPtr_Initiate_Public_Void_IKSolverFullBody_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain.ChildConstraint>.NativeClassPtr, 100672891);
				FBIKChain.ChildConstraint.NativeMethodInfoPtr_OnPreSolve_Public_Void_IKSolverFullBody_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain.ChildConstraint>.NativeClassPtr, 100672892);
				FBIKChain.ChildConstraint.NativeMethodInfoPtr_Solve_Public_Void_IKSolverFullBody_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<FBIKChain.ChildConstraint>.NativeClassPtr, 100672893);
			}

			// Token: 0x06007F3B RID: 32571 RVA: 0x0000A688 File Offset: 0x00008888
			public ChildConstraint(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002B5E RID: 11102
			// (get) Token: 0x06007F3C RID: 32572 RVA: 0x00206B18 File Offset: 0x00204D18
			// (set) Token: 0x06007F3D RID: 32573 RVA: 0x00206B40 File Offset: 0x00204D40
			public unsafe float pushElasticity
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.ChildConstraint.NativeFieldInfoPtr_pushElasticity);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.ChildConstraint.NativeFieldInfoPtr_pushElasticity)) = value;
				}
			}

			// Token: 0x17002B5F RID: 11103
			// (get) Token: 0x06007F3E RID: 32574 RVA: 0x00206B64 File Offset: 0x00204D64
			// (set) Token: 0x06007F3F RID: 32575 RVA: 0x00206B8C File Offset: 0x00204D8C
			public unsafe float pullElasticity
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.ChildConstraint.NativeFieldInfoPtr_pullElasticity);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.ChildConstraint.NativeFieldInfoPtr_pullElasticity)) = value;
				}
			}

			// Token: 0x17002B60 RID: 11104
			// (get) Token: 0x06007F40 RID: 32576 RVA: 0x00206BB0 File Offset: 0x00204DB0
			// (set) Token: 0x06007F41 RID: 32577 RVA: 0x00206BE4 File Offset: 0x00204DE4
			public unsafe Transform bone1
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.ChildConstraint.NativeFieldInfoPtr_bone1);
					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(FBIKChain.ChildConstraint.NativeFieldInfoPtr_bone1), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x17002B61 RID: 11105
			// (get) Token: 0x06007F42 RID: 32578 RVA: 0x00206C0C File Offset: 0x00204E0C
			// (set) Token: 0x06007F43 RID: 32579 RVA: 0x00206C40 File Offset: 0x00204E40
			public unsafe Transform bone2
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.ChildConstraint.NativeFieldInfoPtr_bone2);
					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(FBIKChain.ChildConstraint.NativeFieldInfoPtr_bone2), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x17002B62 RID: 11106
			// (get) Token: 0x06007F44 RID: 32580 RVA: 0x00206C68 File Offset: 0x00204E68
			// (set) Token: 0x06007F45 RID: 32581 RVA: 0x00206C90 File Offset: 0x00204E90
			public unsafe float _nominalDistance_k__BackingField
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.ChildConstraint.NativeFieldInfoPtr__nominalDistance_k__BackingField);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.ChildConstraint.NativeFieldInfoPtr__nominalDistance_k__BackingField)) = value;
				}
			}

			// Token: 0x17002B63 RID: 11107
			// (get) Token: 0x06007F46 RID: 32582 RVA: 0x00206CB4 File Offset: 0x00204EB4
			// (set) Token: 0x06007F47 RID: 32583 RVA: 0x00206CDC File Offset: 0x00204EDC
			public unsafe bool _isRigid_k__BackingField
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.ChildConstraint.NativeFieldInfoPtr__isRigid_k__BackingField);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.ChildConstraint.NativeFieldInfoPtr__isRigid_k__BackingField)) = value;
				}
			}

			// Token: 0x17002B64 RID: 11108
			// (get) Token: 0x06007F48 RID: 32584 RVA: 0x00206D00 File Offset: 0x00204F00
			// (set) Token: 0x06007F49 RID: 32585 RVA: 0x00206D28 File Offset: 0x00204F28
			public unsafe float crossFade
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.ChildConstraint.NativeFieldInfoPtr_crossFade);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.ChildConstraint.NativeFieldInfoPtr_crossFade)) = value;
				}
			}

			// Token: 0x17002B65 RID: 11109
			// (get) Token: 0x06007F4A RID: 32586 RVA: 0x00206D4C File Offset: 0x00204F4C
			// (set) Token: 0x06007F4B RID: 32587 RVA: 0x00206D74 File Offset: 0x00204F74
			public unsafe float inverseCrossFade
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.ChildConstraint.NativeFieldInfoPtr_inverseCrossFade);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.ChildConstraint.NativeFieldInfoPtr_inverseCrossFade)) = value;
				}
			}

			// Token: 0x17002B66 RID: 11110
			// (get) Token: 0x06007F4C RID: 32588 RVA: 0x00206D98 File Offset: 0x00204F98
			// (set) Token: 0x06007F4D RID: 32589 RVA: 0x00206DC0 File Offset: 0x00204FC0
			public unsafe int chain1Index
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.ChildConstraint.NativeFieldInfoPtr_chain1Index);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.ChildConstraint.NativeFieldInfoPtr_chain1Index)) = value;
				}
			}

			// Token: 0x17002B67 RID: 11111
			// (get) Token: 0x06007F4E RID: 32590 RVA: 0x00206DE4 File Offset: 0x00204FE4
			// (set) Token: 0x06007F4F RID: 32591 RVA: 0x00206E0C File Offset: 0x0020500C
			public unsafe int chain2Index
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.ChildConstraint.NativeFieldInfoPtr_chain2Index);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(FBIKChain.ChildConstraint.NativeFieldInfoPtr_chain2Index)) = value;
				}
			}

			// Token: 0x040054E1 RID: 21729
			private static readonly IntPtr NativeFieldInfoPtr_pushElasticity;

			// Token: 0x040054E2 RID: 21730
			private static readonly IntPtr NativeFieldInfoPtr_pullElasticity;

			// Token: 0x040054E3 RID: 21731
			private static readonly IntPtr NativeFieldInfoPtr_bone1;

			// Token: 0x040054E4 RID: 21732
			private static readonly IntPtr NativeFieldInfoPtr_bone2;

			// Token: 0x040054E5 RID: 21733
			private static readonly IntPtr NativeFieldInfoPtr__nominalDistance_k__BackingField;

			// Token: 0x040054E6 RID: 21734
			private static readonly IntPtr NativeFieldInfoPtr__isRigid_k__BackingField;

			// Token: 0x040054E7 RID: 21735
			private static readonly IntPtr NativeFieldInfoPtr_crossFade;

			// Token: 0x040054E8 RID: 21736
			private static readonly IntPtr NativeFieldInfoPtr_inverseCrossFade;

			// Token: 0x040054E9 RID: 21737
			private static readonly IntPtr NativeFieldInfoPtr_chain1Index;

			// Token: 0x040054EA RID: 21738
			private static readonly IntPtr NativeFieldInfoPtr_chain2Index;

			// Token: 0x040054EB RID: 21739
			private static readonly IntPtr NativeMethodInfoPtr_get_nominalDistance_Public_get_Single_0;

			// Token: 0x040054EC RID: 21740
			private static readonly IntPtr NativeMethodInfoPtr_set_nominalDistance_Private_set_Void_Single_0;

			// Token: 0x040054ED RID: 21741
			private static readonly IntPtr NativeMethodInfoPtr_get_isRigid_Public_get_Boolean_0;

			// Token: 0x040054EE RID: 21742
			private static readonly IntPtr NativeMethodInfoPtr_set_isRigid_Private_set_Void_Boolean_0;

			// Token: 0x040054EF RID: 21743
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_Transform_Transform_Single_Single_0;

			// Token: 0x040054F0 RID: 21744
			private static readonly IntPtr NativeMethodInfoPtr_Initiate_Public_Void_IKSolverFullBody_0;

			// Token: 0x040054F1 RID: 21745
			private static readonly IntPtr NativeMethodInfoPtr_OnPreSolve_Public_Void_IKSolverFullBody_0;

			// Token: 0x040054F2 RID: 21746
			private static readonly IntPtr NativeMethodInfoPtr_Solve_Public_Void_IKSolverFullBody_0;
		}

		// Token: 0x02000428 RID: 1064
		[Serializable]
		public enum Smoothing
		{
			// Token: 0x040054F4 RID: 21748
			None,
			// Token: 0x040054F5 RID: 21749
			Exponential,
			// Token: 0x040054F6 RID: 21750
			Cubic
		}
	}
}
