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

namespace RootMotion.FinalIK
{
	// Token: 0x02000467 RID: 1127
	public class GrounderQuadruped : Grounder
	{
		// Token: 0x060084EA RID: 34026 RVA: 0x0021E608 File Offset: 0x0021C808
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 627137, XrefRangeEnd = 627140, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe override void OpenUserManual()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), GrounderQuadruped.NativeMethodInfoPtr_OpenUserManual_Protected_Virtual_Void_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x060084EB RID: 34027 RVA: 0x0021E658 File Offset: 0x0021C858
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 627140, XrefRangeEnd = 627143, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe override void OpenScriptReference()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), GrounderQuadruped.NativeMethodInfoPtr_OpenScriptReference_Protected_Virtual_Void_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x060084EC RID: 34028 RVA: 0x0021E6A8 File Offset: 0x0021C8A8
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 627143, XrefRangeEnd = 627146, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe override void ResetPosition()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), GrounderQuadruped.NativeMethodInfoPtr_ResetPosition_Public_Virtual_Void_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x060084ED RID: 34029 RVA: 0x0021E6F8 File Offset: 0x0021C8F8
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 627146, XrefRangeEnd = 627158, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe bool IsReadyToInitiate()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(GrounderQuadruped.NativeMethodInfoPtr_IsReadyToInitiate_Private_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x060084EE RID: 34030 RVA: 0x0021E748 File Offset: 0x0021C948
		[CallerCount(4)]
		[CachedScanResults(RefRangeStart = 627175, RefRangeEnd = 627179, XrefRangeStart = 627158, XrefRangeEnd = 627175, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe bool IsReadyToInitiateLegs(Il2CppReferenceArray<IK> ikComponents)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(ikComponents);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(GrounderQuadruped.NativeMethodInfoPtr_IsReadyToInitiateLegs_Private_Boolean_Il2CppReferenceArray_1_IK_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}
		}

		// Token: 0x060084EF RID: 34031 RVA: 0x0021E7B0 File Offset: 0x0021C9B0
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 627179, XrefRangeEnd = 627180, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void OnDisable()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(GrounderQuadruped.NativeMethodInfoPtr_OnDisable_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x060084F0 RID: 34032 RVA: 0x0021E7F4 File Offset: 0x0021C9F4
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 627180, XrefRangeEnd = 627194, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void Update()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(GrounderQuadruped.NativeMethodInfoPtr_Update_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x060084F1 RID: 34033 RVA: 0x0021E838 File Offset: 0x0021CA38
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 627225, RefRangeEnd = 627226, XrefRangeStart = 627194, XrefRangeEnd = 627225, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void Initiate()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(GrounderQuadruped.NativeMethodInfoPtr_Initiate_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x060084F2 RID: 34034 RVA: 0x0021E87C File Offset: 0x0021CA7C
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 627251, RefRangeEnd = 627253, XrefRangeStart = 627226, XrefRangeEnd = 627251, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe Il2CppReferenceArray<Transform> InitiateFeet(Il2CppReferenceArray<IK> ikComponents, ref Il2CppReferenceArray<GrounderQuadruped.Foot> f, int indexOffset)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(ikComponents);
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtrNotNull(f);
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref indexOffset;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(GrounderQuadruped.NativeMethodInfoPtr_InitiateFeet_Private_Il2CppReferenceArray_1_Transform_Il2CppReferenceArray_1_IK_byref_Il2CppReferenceArray_1_Foot_Int32_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			IntPtr intPtr3 = intPtr;
			return (intPtr3 != 0) ? new Il2CppReferenceArray<Transform>(intPtr3) : null;
		}

		// Token: 0x060084F3 RID: 34035 RVA: 0x0021E918 File Offset: 0x0021CB18
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 627253, XrefRangeEnd = 627261, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void LateUpdate()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(GrounderQuadruped.NativeMethodInfoPtr_LateUpdate_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x060084F4 RID: 34036 RVA: 0x0021E95C File Offset: 0x0021CB5C
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 627278, RefRangeEnd = 627279, XrefRangeStart = 627261, XrefRangeEnd = 627278, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void RootRotation()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(GrounderQuadruped.NativeMethodInfoPtr_RootRotation_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x060084F5 RID: 34037 RVA: 0x0021E9A0 File Offset: 0x0021CBA0
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 627279, XrefRangeEnd = 627329, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void OnSolverUpdate()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(GrounderQuadruped.NativeMethodInfoPtr_OnSolverUpdate_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x060084F6 RID: 34038 RVA: 0x0021E9E4 File Offset: 0x0021CBE4
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 627342, RefRangeEnd = 627343, XrefRangeStart = 627329, XrefRangeEnd = 627342, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void UpdateForefeetRoot()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(GrounderQuadruped.NativeMethodInfoPtr_UpdateForefeetRoot_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x060084F7 RID: 34039 RVA: 0x0021EA28 File Offset: 0x0021CC28
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 627346, RefRangeEnd = 627347, XrefRangeStart = 627343, XrefRangeEnd = 627346, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void SetFootIK(GrounderQuadruped.Foot foot, float maxOffset)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.il2cpp_object_unbox(IL2CPP.Il2CppObjectBaseToPtrNotNull(foot));
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref maxOffset;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(GrounderQuadruped.NativeMethodInfoPtr_SetFootIK_Private_Void_Foot_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x060084F8 RID: 34040 RVA: 0x0021EA9C File Offset: 0x0021CC9C
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 627347, XrefRangeEnd = 627366, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void OnPostSolverUpdate()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(GrounderQuadruped.NativeMethodInfoPtr_OnPostSolverUpdate_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x060084F9 RID: 34041 RVA: 0x0021EAE0 File Offset: 0x0021CCE0
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 627366, XrefRangeEnd = 627368, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void OnDestroy()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(GrounderQuadruped.NativeMethodInfoPtr_OnDestroy_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x060084FA RID: 34042 RVA: 0x0021EB24 File Offset: 0x0021CD24
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 627390, RefRangeEnd = 627392, XrefRangeStart = 627368, XrefRangeEnd = 627390, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void DestroyLegs(Il2CppReferenceArray<IK> ikComponents)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(ikComponents);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(GrounderQuadruped.NativeMethodInfoPtr_DestroyLegs_Private_Void_Il2CppReferenceArray_1_IK_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}
		}

		// Token: 0x060084FB RID: 34043 RVA: 0x0021EB80 File Offset: 0x0021CD80
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 627392, XrefRangeEnd = 627403, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe GrounderQuadruped()
			: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr))
		{
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(GrounderQuadruped.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x060084FC RID: 34044 RVA: 0x0021EBCC File Offset: 0x0021CDCC
		// Note: this type is marked as 'beforefieldinit'.
		static GrounderQuadruped()
		{
			Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr = IL2CPP.GetIl2CppClass("Assembly-CSharp.dll", "RootMotion.FinalIK", "GrounderQuadruped");
			IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr);
			GrounderQuadruped.NativeFieldInfoPtr_forelegSolver = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, "forelegSolver");
			GrounderQuadruped.NativeFieldInfoPtr_rootRotationWeight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, "rootRotationWeight");
			GrounderQuadruped.NativeFieldInfoPtr_minRootRotation = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, "minRootRotation");
			GrounderQuadruped.NativeFieldInfoPtr_maxRootRotation = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, "maxRootRotation");
			GrounderQuadruped.NativeFieldInfoPtr_rootRotationSpeed = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, "rootRotationSpeed");
			GrounderQuadruped.NativeFieldInfoPtr_maxLegOffset = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, "maxLegOffset");
			GrounderQuadruped.NativeFieldInfoPtr_maxForeLegOffset = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, "maxForeLegOffset");
			GrounderQuadruped.NativeFieldInfoPtr_maintainHeadRotationWeight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, "maintainHeadRotationWeight");
			GrounderQuadruped.NativeFieldInfoPtr_characterRoot = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, "characterRoot");
			GrounderQuadruped.NativeFieldInfoPtr_pelvis = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, "pelvis");
			GrounderQuadruped.NativeFieldInfoPtr_lastSpineBone = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, "lastSpineBone");
			GrounderQuadruped.NativeFieldInfoPtr_head = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, "head");
			GrounderQuadruped.NativeFieldInfoPtr_legs = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, "legs");
			GrounderQuadruped.NativeFieldInfoPtr_forelegs = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, "forelegs");
			GrounderQuadruped.NativeFieldInfoPtr_gravity = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, "gravity");
			GrounderQuadruped.NativeFieldInfoPtr_feet = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, "feet");
			GrounderQuadruped.NativeFieldInfoPtr_animatedPelvisLocalPosition = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, "animatedPelvisLocalPosition");
			GrounderQuadruped.NativeFieldInfoPtr_animatedPelvisLocalRotation = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, "animatedPelvisLocalRotation");
			GrounderQuadruped.NativeFieldInfoPtr_animatedHeadLocalRotation = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, "animatedHeadLocalRotation");
			GrounderQuadruped.NativeFieldInfoPtr_solvedPelvisLocalPosition = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, "solvedPelvisLocalPosition");
			GrounderQuadruped.NativeFieldInfoPtr_solvedPelvisLocalRotation = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, "solvedPelvisLocalRotation");
			GrounderQuadruped.NativeFieldInfoPtr_solvedHeadLocalRotation = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, "solvedHeadLocalRotation");
			GrounderQuadruped.NativeFieldInfoPtr_solvedFeet = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, "solvedFeet");
			GrounderQuadruped.NativeFieldInfoPtr_solved = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, "solved");
			GrounderQuadruped.NativeFieldInfoPtr_angle = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, "angle");
			GrounderQuadruped.NativeFieldInfoPtr_forefeetRoot = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, "forefeetRoot");
			GrounderQuadruped.NativeFieldInfoPtr_headRotation = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, "headRotation");
			GrounderQuadruped.NativeFieldInfoPtr_lastWeight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, "lastWeight");
			GrounderQuadruped.NativeMethodInfoPtr_OpenUserManual_Protected_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, 100673381);
			GrounderQuadruped.NativeMethodInfoPtr_OpenScriptReference_Protected_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, 100673382);
			GrounderQuadruped.NativeMethodInfoPtr_ResetPosition_Public_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, 100673383);
			GrounderQuadruped.NativeMethodInfoPtr_IsReadyToInitiate_Private_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, 100673384);
			GrounderQuadruped.NativeMethodInfoPtr_IsReadyToInitiateLegs_Private_Boolean_Il2CppReferenceArray_1_IK_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, 100673385);
			GrounderQuadruped.NativeMethodInfoPtr_OnDisable_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, 100673386);
			GrounderQuadruped.NativeMethodInfoPtr_Update_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, 100673387);
			GrounderQuadruped.NativeMethodInfoPtr_Initiate_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, 100673388);
			GrounderQuadruped.NativeMethodInfoPtr_InitiateFeet_Private_Il2CppReferenceArray_1_Transform_Il2CppReferenceArray_1_IK_byref_Il2CppReferenceArray_1_Foot_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, 100673389);
			GrounderQuadruped.NativeMethodInfoPtr_LateUpdate_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, 100673390);
			GrounderQuadruped.NativeMethodInfoPtr_RootRotation_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, 100673391);
			GrounderQuadruped.NativeMethodInfoPtr_OnSolverUpdate_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, 100673392);
			GrounderQuadruped.NativeMethodInfoPtr_UpdateForefeetRoot_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, 100673393);
			GrounderQuadruped.NativeMethodInfoPtr_SetFootIK_Private_Void_Foot_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, 100673394);
			GrounderQuadruped.NativeMethodInfoPtr_OnPostSolverUpdate_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, 100673395);
			GrounderQuadruped.NativeMethodInfoPtr_OnDestroy_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, 100673396);
			GrounderQuadruped.NativeMethodInfoPtr_DestroyLegs_Private_Void_Il2CppReferenceArray_1_IK_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, 100673397);
			GrounderQuadruped.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, 100673398);
		}

		// Token: 0x060084FD RID: 34045 RVA: 0x0021CF74 File Offset: 0x0021B174
		public GrounderQuadruped(IntPtr pointer)
			: base(pointer)
		{
		}

		// Token: 0x17002D1B RID: 11547
		// (get) Token: 0x060084FE RID: 34046 RVA: 0x0021EF94 File Offset: 0x0021D194
		// (set) Token: 0x060084FF RID: 34047 RVA: 0x0021EFC8 File Offset: 0x0021D1C8
		public unsafe Grounding forelegSolver
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_forelegSolver);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new Grounding(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_forelegSolver), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002D1C RID: 11548
		// (get) Token: 0x06008500 RID: 34048 RVA: 0x0021EFF0 File Offset: 0x0021D1F0
		// (set) Token: 0x06008501 RID: 34049 RVA: 0x0021F018 File Offset: 0x0021D218
		public unsafe float rootRotationWeight
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_rootRotationWeight);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_rootRotationWeight)) = value;
			}
		}

		// Token: 0x17002D1D RID: 11549
		// (get) Token: 0x06008502 RID: 34050 RVA: 0x0021F03C File Offset: 0x0021D23C
		// (set) Token: 0x06008503 RID: 34051 RVA: 0x0021F064 File Offset: 0x0021D264
		public unsafe float minRootRotation
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_minRootRotation);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_minRootRotation)) = value;
			}
		}

		// Token: 0x17002D1E RID: 11550
		// (get) Token: 0x06008504 RID: 34052 RVA: 0x0021F088 File Offset: 0x0021D288
		// (set) Token: 0x06008505 RID: 34053 RVA: 0x0021F0B0 File Offset: 0x0021D2B0
		public unsafe float maxRootRotation
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_maxRootRotation);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_maxRootRotation)) = value;
			}
		}

		// Token: 0x17002D1F RID: 11551
		// (get) Token: 0x06008506 RID: 34054 RVA: 0x0021F0D4 File Offset: 0x0021D2D4
		// (set) Token: 0x06008507 RID: 34055 RVA: 0x0021F0FC File Offset: 0x0021D2FC
		public unsafe float rootRotationSpeed
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_rootRotationSpeed);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_rootRotationSpeed)) = value;
			}
		}

		// Token: 0x17002D20 RID: 11552
		// (get) Token: 0x06008508 RID: 34056 RVA: 0x0021F120 File Offset: 0x0021D320
		// (set) Token: 0x06008509 RID: 34057 RVA: 0x0021F148 File Offset: 0x0021D348
		public unsafe float maxLegOffset
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_maxLegOffset);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_maxLegOffset)) = value;
			}
		}

		// Token: 0x17002D21 RID: 11553
		// (get) Token: 0x0600850A RID: 34058 RVA: 0x0021F16C File Offset: 0x0021D36C
		// (set) Token: 0x0600850B RID: 34059 RVA: 0x0021F194 File Offset: 0x0021D394
		public unsafe float maxForeLegOffset
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_maxForeLegOffset);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_maxForeLegOffset)) = value;
			}
		}

		// Token: 0x17002D22 RID: 11554
		// (get) Token: 0x0600850C RID: 34060 RVA: 0x0021F1B8 File Offset: 0x0021D3B8
		// (set) Token: 0x0600850D RID: 34061 RVA: 0x0021F1E0 File Offset: 0x0021D3E0
		public unsafe float maintainHeadRotationWeight
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_maintainHeadRotationWeight);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_maintainHeadRotationWeight)) = value;
			}
		}

		// Token: 0x17002D23 RID: 11555
		// (get) Token: 0x0600850E RID: 34062 RVA: 0x0021F204 File Offset: 0x0021D404
		// (set) Token: 0x0600850F RID: 34063 RVA: 0x0021F238 File Offset: 0x0021D438
		public unsafe Transform characterRoot
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_characterRoot);
				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(GrounderQuadruped.NativeFieldInfoPtr_characterRoot), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002D24 RID: 11556
		// (get) Token: 0x06008510 RID: 34064 RVA: 0x0021F260 File Offset: 0x0021D460
		// (set) Token: 0x06008511 RID: 34065 RVA: 0x0021F294 File Offset: 0x0021D494
		public unsafe Transform pelvis
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_pelvis);
				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(GrounderQuadruped.NativeFieldInfoPtr_pelvis), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002D25 RID: 11557
		// (get) Token: 0x06008512 RID: 34066 RVA: 0x0021F2BC File Offset: 0x0021D4BC
		// (set) Token: 0x06008513 RID: 34067 RVA: 0x0021F2F0 File Offset: 0x0021D4F0
		public unsafe Transform lastSpineBone
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_lastSpineBone);
				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(GrounderQuadruped.NativeFieldInfoPtr_lastSpineBone), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002D26 RID: 11558
		// (get) Token: 0x06008514 RID: 34068 RVA: 0x0021F318 File Offset: 0x0021D518
		// (set) Token: 0x06008515 RID: 34069 RVA: 0x0021F34C File Offset: 0x0021D54C
		public unsafe Transform head
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_head);
				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(GrounderQuadruped.NativeFieldInfoPtr_head), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002D27 RID: 11559
		// (get) Token: 0x06008516 RID: 34070 RVA: 0x0021F374 File Offset: 0x0021D574
		// (set) Token: 0x06008517 RID: 34071 RVA: 0x0021F3A8 File Offset: 0x0021D5A8
		public unsafe Il2CppReferenceArray<IK> legs
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_legs);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new Il2CppReferenceArray<IK>(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_legs), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002D28 RID: 11560
		// (get) Token: 0x06008518 RID: 34072 RVA: 0x0021F3D0 File Offset: 0x0021D5D0
		// (set) Token: 0x06008519 RID: 34073 RVA: 0x0021F404 File Offset: 0x0021D604
		public unsafe Il2CppReferenceArray<IK> forelegs
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_forelegs);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new Il2CppReferenceArray<IK>(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_forelegs), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002D29 RID: 11561
		// (get) Token: 0x0600851A RID: 34074 RVA: 0x0021F42C File Offset: 0x0021D62C
		// (set) Token: 0x0600851B RID: 34075 RVA: 0x0021F454 File Offset: 0x0021D654
		public unsafe Vector3 gravity
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_gravity);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_gravity)) = value;
			}
		}

		// Token: 0x17002D2A RID: 11562
		// (get) Token: 0x0600851C RID: 34076 RVA: 0x0021F478 File Offset: 0x0021D678
		// (set) Token: 0x0600851D RID: 34077 RVA: 0x0021F4AC File Offset: 0x0021D6AC
		public unsafe Il2CppReferenceArray<GrounderQuadruped.Foot> feet
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_feet);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new Il2CppReferenceArray<GrounderQuadruped.Foot>(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_feet), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002D2B RID: 11563
		// (get) Token: 0x0600851E RID: 34078 RVA: 0x0021F4D4 File Offset: 0x0021D6D4
		// (set) Token: 0x0600851F RID: 34079 RVA: 0x0021F4FC File Offset: 0x0021D6FC
		public unsafe Vector3 animatedPelvisLocalPosition
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_animatedPelvisLocalPosition);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_animatedPelvisLocalPosition)) = value;
			}
		}

		// Token: 0x17002D2C RID: 11564
		// (get) Token: 0x06008520 RID: 34080 RVA: 0x0021F520 File Offset: 0x0021D720
		// (set) Token: 0x06008521 RID: 34081 RVA: 0x0021F548 File Offset: 0x0021D748
		public unsafe Quaternion animatedPelvisLocalRotation
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_animatedPelvisLocalRotation);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_animatedPelvisLocalRotation)) = value;
			}
		}

		// Token: 0x17002D2D RID: 11565
		// (get) Token: 0x06008522 RID: 34082 RVA: 0x0021F56C File Offset: 0x0021D76C
		// (set) Token: 0x06008523 RID: 34083 RVA: 0x0021F594 File Offset: 0x0021D794
		public unsafe Quaternion animatedHeadLocalRotation
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_animatedHeadLocalRotation);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_animatedHeadLocalRotation)) = value;
			}
		}

		// Token: 0x17002D2E RID: 11566
		// (get) Token: 0x06008524 RID: 34084 RVA: 0x0021F5B8 File Offset: 0x0021D7B8
		// (set) Token: 0x06008525 RID: 34085 RVA: 0x0021F5E0 File Offset: 0x0021D7E0
		public unsafe Vector3 solvedPelvisLocalPosition
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_solvedPelvisLocalPosition);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_solvedPelvisLocalPosition)) = value;
			}
		}

		// Token: 0x17002D2F RID: 11567
		// (get) Token: 0x06008526 RID: 34086 RVA: 0x0021F604 File Offset: 0x0021D804
		// (set) Token: 0x06008527 RID: 34087 RVA: 0x0021F62C File Offset: 0x0021D82C
		public unsafe Quaternion solvedPelvisLocalRotation
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_solvedPelvisLocalRotation);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_solvedPelvisLocalRotation)) = value;
			}
		}

		// Token: 0x17002D30 RID: 11568
		// (get) Token: 0x06008528 RID: 34088 RVA: 0x0021F650 File Offset: 0x0021D850
		// (set) Token: 0x06008529 RID: 34089 RVA: 0x0021F678 File Offset: 0x0021D878
		public unsafe Quaternion solvedHeadLocalRotation
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_solvedHeadLocalRotation);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_solvedHeadLocalRotation)) = value;
			}
		}

		// Token: 0x17002D31 RID: 11569
		// (get) Token: 0x0600852A RID: 34090 RVA: 0x0021F69C File Offset: 0x0021D89C
		// (set) Token: 0x0600852B RID: 34091 RVA: 0x0021F6C4 File Offset: 0x0021D8C4
		public unsafe int solvedFeet
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_solvedFeet);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_solvedFeet)) = value;
			}
		}

		// Token: 0x17002D32 RID: 11570
		// (get) Token: 0x0600852C RID: 34092 RVA: 0x0021F6E8 File Offset: 0x0021D8E8
		// (set) Token: 0x0600852D RID: 34093 RVA: 0x0021F710 File Offset: 0x0021D910
		public unsafe bool solved
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_solved);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_solved)) = value;
			}
		}

		// Token: 0x17002D33 RID: 11571
		// (get) Token: 0x0600852E RID: 34094 RVA: 0x0021F734 File Offset: 0x0021D934
		// (set) Token: 0x0600852F RID: 34095 RVA: 0x0021F75C File Offset: 0x0021D95C
		public unsafe float angle
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_angle);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_angle)) = value;
			}
		}

		// Token: 0x17002D34 RID: 11572
		// (get) Token: 0x06008530 RID: 34096 RVA: 0x0021F780 File Offset: 0x0021D980
		// (set) Token: 0x06008531 RID: 34097 RVA: 0x0021F7B4 File Offset: 0x0021D9B4
		public unsafe Transform forefeetRoot
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_forefeetRoot);
				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(GrounderQuadruped.NativeFieldInfoPtr_forefeetRoot), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002D35 RID: 11573
		// (get) Token: 0x06008532 RID: 34098 RVA: 0x0021F7DC File Offset: 0x0021D9DC
		// (set) Token: 0x06008533 RID: 34099 RVA: 0x0021F804 File Offset: 0x0021DA04
		public unsafe Quaternion headRotation
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_headRotation);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_headRotation)) = value;
			}
		}

		// Token: 0x17002D36 RID: 11574
		// (get) Token: 0x06008534 RID: 34100 RVA: 0x0021F828 File Offset: 0x0021DA28
		// (set) Token: 0x06008535 RID: 34101 RVA: 0x0021F850 File Offset: 0x0021DA50
		public unsafe float lastWeight
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_lastWeight);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.NativeFieldInfoPtr_lastWeight)) = value;
			}
		}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		// Token: 0x04005908 RID: 22792
		private static readonly IntPtr NativeMethodInfoPtr_InitiateFeet_Private_Il2CppReferenceArray_1_Transform_Il2CppReferenceArray_1_IK_byref_Il2CppReferenceArray_1_Foot_Int32_0;

		// Token: 0x04005909 RID: 22793
		private static readonly IntPtr NativeMethodInfoPtr_LateUpdate_Private_Void_0;

		// Token: 0x0400590A RID: 22794
		private static readonly IntPtr NativeMethodInfoPtr_RootRotation_Private_Void_0;

		// Token: 0x0400590B RID: 22795
		private static readonly IntPtr NativeMethodInfoPtr_OnSolverUpdate_Private_Void_0;

		// Token: 0x0400590C RID: 22796
		private static readonly IntPtr NativeMethodInfoPtr_UpdateForefeetRoot_Private_Void_0;

		// Token: 0x0400590D RID: 22797
		private static readonly IntPtr NativeMethodInfoPtr_SetFootIK_Private_Void_Foot_Single_0;

		// Token: 0x0400590E RID: 22798
		private static readonly IntPtr NativeMethodInfoPtr_OnPostSolverUpdate_Private_Void_0;

		// Token: 0x0400590F RID: 22799
		private static readonly IntPtr NativeMethodInfoPtr_OnDestroy_Private_Void_0;

		// Token: 0x04005910 RID: 22800
		private static readonly IntPtr NativeMethodInfoPtr_DestroyLegs_Private_Void_Il2CppReferenceArray_1_IK_0;

		// Token: 0x04005911 RID: 22801
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

		// Token: 0x02000468 RID: 1128
		public sealed class Foot : ValueType
		{
			// Token: 0x06008536 RID: 34102 RVA: 0x0021F874 File Offset: 0x0021DA74
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 627136, RefRangeEnd = 627137, XrefRangeStart = 627132, XrefRangeEnd = 627136, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe Foot(IKSolver solver, Transform transform)
				: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<GrounderQuadruped.Foot>.NativeClassPtr))
			{
				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)] = IL2CPP.Il2CppObjectBaseToPtr(transform);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(GrounderQuadruped.Foot.NativeMethodInfoPtr__ctor_Public_Void_IKSolver_Transform_0, IL2CPP.il2cpp_object_unbox(IL2CPP.Il2CppObjectBaseToPtrNotNull(this)), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008537 RID: 34103 RVA: 0x0021F8F4 File Offset: 0x0021DAF4
			// Note: this type is marked as 'beforefieldinit'.
			static Foot()
			{
				Il2CppClassPointerStore<GrounderQuadruped.Foot>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, "Foot");
				IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<GrounderQuadruped.Foot>.NativeClassPtr);
				GrounderQuadruped.Foot.NativeFieldInfoPtr_solver = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<GrounderQuadruped.Foot>.NativeClassPtr, "solver");
				GrounderQuadruped.Foot.NativeFieldInfoPtr_transform = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<GrounderQuadruped.Foot>.NativeClassPtr, "transform");
				GrounderQuadruped.Foot.NativeFieldInfoPtr_rotation = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<GrounderQuadruped.Foot>.NativeClassPtr, "rotation");
				GrounderQuadruped.Foot.NativeFieldInfoPtr_leg = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<GrounderQuadruped.Foot>.NativeClassPtr, "leg");
				GrounderQuadruped.Foot.NativeMethodInfoPtr__ctor_Public_Void_IKSolver_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<GrounderQuadruped.Foot>.NativeClassPtr, 100673399);
			}

			// Token: 0x06008538 RID: 34104 RVA: 0x001295E7 File Offset: 0x001277E7
			public Foot(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x06008539 RID: 34105 RVA: 0x0021F984 File Offset: 0x0021DB84
			public unsafe Foot()
			{
				IntPtr intPtr = stackalloc byte[(UIntPtr)IL2CPP.il2cpp_class_value_size(Il2CppClassPointerStore<GrounderQuadruped.Foot>.NativeClassPtr, (UIntPtr)0)];
				base..ctor(IL2CPP.il2cpp_value_box(Il2CppClassPointerStore<GrounderQuadruped.Foot>.NativeClassPtr, intPtr));
			}

			// Token: 0x17002D37 RID: 11575
			// (get) Token: 0x0600853A RID: 34106 RVA: 0x0021F9B4 File Offset: 0x0021DBB4
			// (set) Token: 0x0600853B RID: 34107 RVA: 0x0021F9E8 File Offset: 0x0021DBE8
			public unsafe IKSolver solver
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.Foot.NativeFieldInfoPtr_solver);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new IKSolver(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.Foot.NativeFieldInfoPtr_solver), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x17002D38 RID: 11576
			// (get) Token: 0x0600853C RID: 34108 RVA: 0x0021FA10 File Offset: 0x0021DC10
			// (set) Token: 0x0600853D RID: 34109 RVA: 0x0021FA44 File Offset: 0x0021DC44
			public unsafe Transform transform
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.Foot.NativeFieldInfoPtr_transform);
					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(GrounderQuadruped.Foot.NativeFieldInfoPtr_transform), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x17002D39 RID: 11577
			// (get) Token: 0x0600853E RID: 34110 RVA: 0x0021FA6C File Offset: 0x0021DC6C
			// (set) Token: 0x0600853F RID: 34111 RVA: 0x0021FA94 File Offset: 0x0021DC94
			public unsafe Quaternion rotation
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.Foot.NativeFieldInfoPtr_rotation);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.Foot.NativeFieldInfoPtr_rotation)) = value;
				}
			}

			// Token: 0x17002D3A RID: 11578
			// (get) Token: 0x06008540 RID: 34112 RVA: 0x0021FAB8 File Offset: 0x0021DCB8
			// (set) Token: 0x06008541 RID: 34113 RVA: 0x0021FAEC File Offset: 0x0021DCEC
			public unsafe Grounding.Leg leg
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.Foot.NativeFieldInfoPtr_leg);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new Grounding.Leg(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(GrounderQuadruped.Foot.NativeFieldInfoPtr_leg), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x04005912 RID: 22802
			private static readonly IntPtr NativeFieldInfoPtr_solver;

			// Token: 0x04005913 RID: 22803
			private static readonly IntPtr NativeFieldInfoPtr_transform;

			// Token: 0x04005914 RID: 22804
			private static readonly IntPtr NativeFieldInfoPtr_rotation;

			// Token: 0x04005915 RID: 22805
			private static readonly IntPtr NativeFieldInfoPtr_leg;

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