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

namespace RootMotion.FinalIK
{
	// Token: 0x0200040F RID: 1039
	public class GrounderQuadruped : Grounder
	{
		// Token: 0x06007C97 RID: 31895 RVA: 0x001FB8CC File Offset: 0x001F9ACC
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 594823, XrefRangeEnd = 594826, 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: 0x06007C98 RID: 31896 RVA: 0x001FB91C File Offset: 0x001F9B1C
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 594826, XrefRangeEnd = 594829, 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: 0x06007C99 RID: 31897 RVA: 0x001FB96C File Offset: 0x001F9B6C
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 594829, XrefRangeEnd = 594832, 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: 0x06007C9A RID: 31898 RVA: 0x001FB9BC File Offset: 0x001F9BBC
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 594832, XrefRangeEnd = 594844, 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: 0x06007C9B RID: 31899 RVA: 0x001FBA0C File Offset: 0x001F9C0C
		[CallerCount(4)]
		[CachedScanResults(RefRangeStart = 594861, RefRangeEnd = 594865, XrefRangeStart = 594844, XrefRangeEnd = 594861, 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: 0x06007C9C RID: 31900 RVA: 0x001FBA74 File Offset: 0x001F9C74
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 594865, XrefRangeEnd = 594866, 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: 0x06007C9D RID: 31901 RVA: 0x001FBAB8 File Offset: 0x001F9CB8
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 594866, XrefRangeEnd = 594880, 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: 0x06007C9E RID: 31902 RVA: 0x001FBAFC File Offset: 0x001F9CFC
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 594911, RefRangeEnd = 594912, XrefRangeStart = 594880, XrefRangeEnd = 594911, 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: 0x06007C9F RID: 31903 RVA: 0x001FBB40 File Offset: 0x001F9D40
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 594937, RefRangeEnd = 594939, XrefRangeStart = 594912, XrefRangeEnd = 594937, 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: 0x06007CA0 RID: 31904 RVA: 0x001FBBDC File Offset: 0x001F9DDC
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 594939, XrefRangeEnd = 594947, 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: 0x06007CA1 RID: 31905 RVA: 0x001FBC20 File Offset: 0x001F9E20
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 594964, RefRangeEnd = 594965, XrefRangeStart = 594947, XrefRangeEnd = 594964, 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: 0x06007CA2 RID: 31906 RVA: 0x001FBC64 File Offset: 0x001F9E64
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 594965, XrefRangeEnd = 595015, 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: 0x06007CA3 RID: 31907 RVA: 0x001FBCA8 File Offset: 0x001F9EA8
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 595028, RefRangeEnd = 595029, XrefRangeStart = 595015, XrefRangeEnd = 595028, 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: 0x06007CA4 RID: 31908 RVA: 0x001FBCEC File Offset: 0x001F9EEC
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 595032, RefRangeEnd = 595033, XrefRangeStart = 595029, XrefRangeEnd = 595032, 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: 0x06007CA5 RID: 31909 RVA: 0x001FBD60 File Offset: 0x001F9F60
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 595033, XrefRangeEnd = 595052, 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: 0x06007CA6 RID: 31910 RVA: 0x001FBDA4 File Offset: 0x001F9FA4
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 595052, XrefRangeEnd = 595054, 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: 0x06007CA7 RID: 31911 RVA: 0x001FBDE8 File Offset: 0x001F9FE8
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 595076, RefRangeEnd = 595078, XrefRangeStart = 595054, XrefRangeEnd = 595076, 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: 0x06007CA8 RID: 31912 RVA: 0x001FBE44 File Offset: 0x001FA044
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 595078, XrefRangeEnd = 595089, 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: 0x06007CA9 RID: 31913 RVA: 0x001FBE90 File Offset: 0x001FA090
		// 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, 100672668);
			GrounderQuadruped.NativeMethodInfoPtr_OpenScriptReference_Protected_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, 100672669);
			GrounderQuadruped.NativeMethodInfoPtr_ResetPosition_Public_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, 100672670);
			GrounderQuadruped.NativeMethodInfoPtr_IsReadyToInitiate_Private_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, 100672671);
			GrounderQuadruped.NativeMethodInfoPtr_IsReadyToInitiateLegs_Private_Boolean_Il2CppReferenceArray_1_IK_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, 100672672);
			GrounderQuadruped.NativeMethodInfoPtr_OnDisable_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, 100672673);
			GrounderQuadruped.NativeMethodInfoPtr_Update_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, 100672674);
			GrounderQuadruped.NativeMethodInfoPtr_Initiate_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, 100672675);
			GrounderQuadruped.NativeMethodInfoPtr_InitiateFeet_Private_Il2CppReferenceArray_1_Transform_Il2CppReferenceArray_1_IK_byref_Il2CppReferenceArray_1_Foot_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, 100672676);
			GrounderQuadruped.NativeMethodInfoPtr_LateUpdate_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, 100672677);
			GrounderQuadruped.NativeMethodInfoPtr_RootRotation_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, 100672678);
			GrounderQuadruped.NativeMethodInfoPtr_OnSolverUpdate_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, 100672679);
			GrounderQuadruped.NativeMethodInfoPtr_UpdateForefeetRoot_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, 100672680);
			GrounderQuadruped.NativeMethodInfoPtr_SetFootIK_Private_Void_Foot_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, 100672681);
			GrounderQuadruped.NativeMethodInfoPtr_OnPostSolverUpdate_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, 100672682);
			GrounderQuadruped.NativeMethodInfoPtr_OnDestroy_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, 100672683);
			GrounderQuadruped.NativeMethodInfoPtr_DestroyLegs_Private_Void_Il2CppReferenceArray_1_IK_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, 100672684);
			GrounderQuadruped.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<GrounderQuadruped>.NativeClassPtr, 100672685);
		}

		// Token: 0x06007CAA RID: 31914 RVA: 0x001FA238 File Offset: 0x001F8438
		public GrounderQuadruped(IntPtr pointer)
			: base(pointer)
		{
		}

		// Token: 0x17002A80 RID: 10880
		// (get) Token: 0x06007CAB RID: 31915 RVA: 0x001FC258 File Offset: 0x001FA458
		// (set) Token: 0x06007CAC RID: 31916 RVA: 0x001FC28C File Offset: 0x001FA48C
		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: 0x17002A81 RID: 10881
		// (get) Token: 0x06007CAD RID: 31917 RVA: 0x001FC2B4 File Offset: 0x001FA4B4
		// (set) Token: 0x06007CAE RID: 31918 RVA: 0x001FC2DC File Offset: 0x001FA4DC
		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: 0x17002A82 RID: 10882
		// (get) Token: 0x06007CAF RID: 31919 RVA: 0x001FC300 File Offset: 0x001FA500
		// (set) Token: 0x06007CB0 RID: 31920 RVA: 0x001FC328 File Offset: 0x001FA528
		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: 0x17002A83 RID: 10883
		// (get) Token: 0x06007CB1 RID: 31921 RVA: 0x001FC34C File Offset: 0x001FA54C
		// (set) Token: 0x06007CB2 RID: 31922 RVA: 0x001FC374 File Offset: 0x001FA574
		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: 0x17002A84 RID: 10884
		// (get) Token: 0x06007CB3 RID: 31923 RVA: 0x001FC398 File Offset: 0x001FA598
		// (set) Token: 0x06007CB4 RID: 31924 RVA: 0x001FC3C0 File Offset: 0x001FA5C0
		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: 0x17002A85 RID: 10885
		// (get) Token: 0x06007CB5 RID: 31925 RVA: 0x001FC3E4 File Offset: 0x001FA5E4
		// (set) Token: 0x06007CB6 RID: 31926 RVA: 0x001FC40C File Offset: 0x001FA60C
		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: 0x17002A86 RID: 10886
		// (get) Token: 0x06007CB7 RID: 31927 RVA: 0x001FC430 File Offset: 0x001FA630
		// (set) Token: 0x06007CB8 RID: 31928 RVA: 0x001FC458 File Offset: 0x001FA658
		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: 0x17002A87 RID: 10887
		// (get) Token: 0x06007CB9 RID: 31929 RVA: 0x001FC47C File Offset: 0x001FA67C
		// (set) Token: 0x06007CBA RID: 31930 RVA: 0x001FC4A4 File Offset: 0x001FA6A4
		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: 0x17002A88 RID: 10888
		// (get) Token: 0x06007CBB RID: 31931 RVA: 0x001FC4C8 File Offset: 0x001FA6C8
		// (set) Token: 0x06007CBC RID: 31932 RVA: 0x001FC4FC File Offset: 0x001FA6FC
		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: 0x17002A89 RID: 10889
		// (get) Token: 0x06007CBD RID: 31933 RVA: 0x001FC524 File Offset: 0x001FA724
		// (set) Token: 0x06007CBE RID: 31934 RVA: 0x001FC558 File Offset: 0x001FA758
		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: 0x17002A8A RID: 10890
		// (get) Token: 0x06007CBF RID: 31935 RVA: 0x001FC580 File Offset: 0x001FA780
		// (set) Token: 0x06007CC0 RID: 31936 RVA: 0x001FC5B4 File Offset: 0x001FA7B4
		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: 0x17002A8B RID: 10891
		// (get) Token: 0x06007CC1 RID: 31937 RVA: 0x001FC5DC File Offset: 0x001FA7DC
		// (set) Token: 0x06007CC2 RID: 31938 RVA: 0x001FC610 File Offset: 0x001FA810
		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: 0x17002A8C RID: 10892
		// (get) Token: 0x06007CC3 RID: 31939 RVA: 0x001FC638 File Offset: 0x001FA838
		// (set) Token: 0x06007CC4 RID: 31940 RVA: 0x001FC66C File Offset: 0x001FA86C
		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: 0x17002A8D RID: 10893
		// (get) Token: 0x06007CC5 RID: 31941 RVA: 0x001FC694 File Offset: 0x001FA894
		// (set) Token: 0x06007CC6 RID: 31942 RVA: 0x001FC6C8 File Offset: 0x001FA8C8
		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: 0x17002A8E RID: 10894
		// (get) Token: 0x06007CC7 RID: 31943 RVA: 0x001FC6F0 File Offset: 0x001FA8F0
		// (set) Token: 0x06007CC8 RID: 31944 RVA: 0x001FC718 File Offset: 0x001FA918
		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: 0x17002A8F RID: 10895
		// (get) Token: 0x06007CC9 RID: 31945 RVA: 0x001FC73C File Offset: 0x001FA93C
		// (set) Token: 0x06007CCA RID: 31946 RVA: 0x001FC770 File Offset: 0x001FA970
		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: 0x17002A90 RID: 10896
		// (get) Token: 0x06007CCB RID: 31947 RVA: 0x001FC798 File Offset: 0x001FA998
		// (set) Token: 0x06007CCC RID: 31948 RVA: 0x001FC7C0 File Offset: 0x001FA9C0
		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: 0x17002A91 RID: 10897
		// (get) Token: 0x06007CCD RID: 31949 RVA: 0x001FC7E4 File Offset: 0x001FA9E4
		// (set) Token: 0x06007CCE RID: 31950 RVA: 0x001FC80C File Offset: 0x001FAA0C
		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: 0x17002A92 RID: 10898
		// (get) Token: 0x06007CCF RID: 31951 RVA: 0x001FC830 File Offset: 0x001FAA30
		// (set) Token: 0x06007CD0 RID: 31952 RVA: 0x001FC858 File Offset: 0x001FAA58
		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: 0x17002A93 RID: 10899
		// (get) Token: 0x06007CD1 RID: 31953 RVA: 0x001FC87C File Offset: 0x001FAA7C
		// (set) Token: 0x06007CD2 RID: 31954 RVA: 0x001FC8A4 File Offset: 0x001FAAA4
		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: 0x17002A94 RID: 10900
		// (get) Token: 0x06007CD3 RID: 31955 RVA: 0x001FC8C8 File Offset: 0x001FAAC8
		// (set) Token: 0x06007CD4 RID: 31956 RVA: 0x001FC8F0 File Offset: 0x001FAAF0
		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: 0x17002A95 RID: 10901
		// (get) Token: 0x06007CD5 RID: 31957 RVA: 0x001FC914 File Offset: 0x001FAB14
		// (set) Token: 0x06007CD6 RID: 31958 RVA: 0x001FC93C File Offset: 0x001FAB3C
		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: 0x17002A96 RID: 10902
		// (get) Token: 0x06007CD7 RID: 31959 RVA: 0x001FC960 File Offset: 0x001FAB60
		// (set) Token: 0x06007CD8 RID: 31960 RVA: 0x001FC988 File Offset: 0x001FAB88
		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: 0x17002A97 RID: 10903
		// (get) Token: 0x06007CD9 RID: 31961 RVA: 0x001FC9AC File Offset: 0x001FABAC
		// (set) Token: 0x06007CDA RID: 31962 RVA: 0x001FC9D4 File Offset: 0x001FABD4
		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: 0x17002A98 RID: 10904
		// (get) Token: 0x06007CDB RID: 31963 RVA: 0x001FC9F8 File Offset: 0x001FABF8
		// (set) Token: 0x06007CDC RID: 31964 RVA: 0x001FCA20 File Offset: 0x001FAC20
		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: 0x17002A99 RID: 10905
		// (get) Token: 0x06007CDD RID: 31965 RVA: 0x001FCA44 File Offset: 0x001FAC44
		// (set) Token: 0x06007CDE RID: 31966 RVA: 0x001FCA78 File Offset: 0x001FAC78
		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: 0x17002A9A RID: 10906
		// (get) Token: 0x06007CDF RID: 31967 RVA: 0x001FCAA0 File Offset: 0x001FACA0
		// (set) Token: 0x06007CE0 RID: 31968 RVA: 0x001FCAC8 File Offset: 0x001FACC8
		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: 0x17002A9B RID: 10907
		// (get) Token: 0x06007CE1 RID: 31969 RVA: 0x001FCAEC File Offset: 0x001FACEC
		// (set) Token: 0x06007CE2 RID: 31970 RVA: 0x001FCB14 File Offset: 0x001FAD14
		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: 0x0400533B RID: 21307
		private static readonly IntPtr NativeFieldInfoPtr_forelegSolver;

		// Token: 0x0400533C RID: 21308
		private static readonly IntPtr NativeFieldInfoPtr_rootRotationWeight;

		// Token: 0x0400533D RID: 21309
		private static readonly IntPtr NativeFieldInfoPtr_minRootRotation;

		// Token: 0x0400533E RID: 21310
		private static readonly IntPtr NativeFieldInfoPtr_maxRootRotation;

		// Token: 0x0400533F RID: 21311
		private static readonly IntPtr NativeFieldInfoPtr_rootRotationSpeed;

		// Token: 0x04005340 RID: 21312
		private static readonly IntPtr NativeFieldInfoPtr_maxLegOffset;

		// Token: 0x04005341 RID: 21313
		private static readonly IntPtr NativeFieldInfoPtr_maxForeLegOffset;

		// Token: 0x04005342 RID: 21314
		private static readonly IntPtr NativeFieldInfoPtr_maintainHeadRotationWeight;

		// Token: 0x04005343 RID: 21315
		private static readonly IntPtr NativeFieldInfoPtr_characterRoot;

		// Token: 0x04005344 RID: 21316
		private static readonly IntPtr NativeFieldInfoPtr_pelvis;

		// Token: 0x04005345 RID: 21317
		private static readonly IntPtr NativeFieldInfoPtr_lastSpineBone;

		// Token: 0x04005346 RID: 21318
		private static readonly IntPtr NativeFieldInfoPtr_head;

		// Token: 0x04005347 RID: 21319
		private static readonly IntPtr NativeFieldInfoPtr_legs;

		// Token: 0x04005348 RID: 21320
		private static readonly IntPtr NativeFieldInfoPtr_forelegs;

		// Token: 0x04005349 RID: 21321
		private static readonly IntPtr NativeFieldInfoPtr_gravity;

		// Token: 0x0400534A RID: 21322
		private static readonly IntPtr NativeFieldInfoPtr_feet;

		// Token: 0x0400534B RID: 21323
		private static readonly IntPtr NativeFieldInfoPtr_animatedPelvisLocalPosition;

		// Token: 0x0400534C RID: 21324
		private static readonly IntPtr NativeFieldInfoPtr_animatedPelvisLocalRotation;

		// Token: 0x0400534D RID: 21325
		private static readonly IntPtr NativeFieldInfoPtr_animatedHeadLocalRotation;

		// Token: 0x0400534E RID: 21326
		private static readonly IntPtr NativeFieldInfoPtr_solvedPelvisLocalPosition;

		// Token: 0x0400534F RID: 21327
		private static readonly IntPtr NativeFieldInfoPtr_solvedPelvisLocalRotation;

		// Token: 0x04005350 RID: 21328
		private static readonly IntPtr NativeFieldInfoPtr_solvedHeadLocalRotation;

		// Token: 0x04005351 RID: 21329
		private static readonly IntPtr NativeFieldInfoPtr_solvedFeet;

		// Token: 0x04005352 RID: 21330
		private static readonly IntPtr NativeFieldInfoPtr_solved;

		// Token: 0x04005353 RID: 21331
		private static readonly IntPtr NativeFieldInfoPtr_angle;

		// Token: 0x04005354 RID: 21332
		private static readonly IntPtr NativeFieldInfoPtr_forefeetRoot;

		// Token: 0x04005355 RID: 21333
		private static readonly IntPtr NativeFieldInfoPtr_headRotation;

		// Token: 0x04005356 RID: 21334
		private static readonly IntPtr NativeFieldInfoPtr_lastWeight;

		// Token: 0x04005357 RID: 21335
		private static readonly IntPtr NativeMethodInfoPtr_OpenUserManual_Protected_Virtual_Void_0;

		// Token: 0x04005358 RID: 21336
		private static readonly IntPtr NativeMethodInfoPtr_OpenScriptReference_Protected_Virtual_Void_0;

		// Token: 0x04005359 RID: 21337
		private static readonly IntPtr NativeMethodInfoPtr_ResetPosition_Public_Virtual_Void_0;

		// Token: 0x0400535A RID: 21338
		private static readonly IntPtr NativeMethodInfoPtr_IsReadyToInitiate_Private_Boolean_0;

		// Token: 0x0400535B RID: 21339
		private static readonly IntPtr NativeMethodInfoPtr_IsReadyToInitiateLegs_Private_Boolean_Il2CppReferenceArray_1_IK_0;

		// Token: 0x0400535C RID: 21340
		private static readonly IntPtr NativeMethodInfoPtr_OnDisable_Private_Void_0;

		// Token: 0x0400535D RID: 21341
		private static readonly IntPtr NativeMethodInfoPtr_Update_Private_Void_0;

		// Token: 0x0400535E RID: 21342
		private static readonly IntPtr NativeMethodInfoPtr_Initiate_Private_Void_0;

		// Token: 0x0400535F RID: 21343
		private static readonly IntPtr NativeMethodInfoPtr_InitiateFeet_Private_Il2CppReferenceArray_1_Transform_Il2CppReferenceArray_1_IK_byref_Il2CppReferenceArray_1_Foot_Int32_0;

		// Token: 0x04005360 RID: 21344
		private static readonly IntPtr NativeMethodInfoPtr_LateUpdate_Private_Void_0;

		// Token: 0x04005361 RID: 21345
		private static readonly IntPtr NativeMethodInfoPtr_RootRotation_Private_Void_0;

		// Token: 0x04005362 RID: 21346
		private static readonly IntPtr NativeMethodInfoPtr_OnSolverUpdate_Private_Void_0;

		// Token: 0x04005363 RID: 21347
		private static readonly IntPtr NativeMethodInfoPtr_UpdateForefeetRoot_Private_Void_0;

		// Token: 0x04005364 RID: 21348
		private static readonly IntPtr NativeMethodInfoPtr_SetFootIK_Private_Void_Foot_Single_0;

		// Token: 0x04005365 RID: 21349
		private static readonly IntPtr NativeMethodInfoPtr_OnPostSolverUpdate_Private_Void_0;

		// Token: 0x04005366 RID: 21350
		private static readonly IntPtr NativeMethodInfoPtr_OnDestroy_Private_Void_0;

		// Token: 0x04005367 RID: 21351
		private static readonly IntPtr NativeMethodInfoPtr_DestroyLegs_Private_Void_Il2CppReferenceArray_1_IK_0;

		// Token: 0x04005368 RID: 21352
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

		// Token: 0x02000410 RID: 1040
		public sealed class Foot : ValueType
		{
			// Token: 0x06007CE3 RID: 31971 RVA: 0x001FCB38 File Offset: 0x001FAD38
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 594822, RefRangeEnd = 594823, XrefRangeStart = 594818, XrefRangeEnd = 594822, 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: 0x06007CE4 RID: 31972 RVA: 0x001FCBB8 File Offset: 0x001FADB8
			// 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, 100672686);
			}

			// Token: 0x06007CE5 RID: 31973 RVA: 0x0011646F File Offset: 0x0011466F
			public Foot(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x06007CE6 RID: 31974 RVA: 0x001FCC48 File Offset: 0x001FAE48
			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: 0x17002A9C RID: 10908
			// (get) Token: 0x06007CE7 RID: 31975 RVA: 0x001FCC78 File Offset: 0x001FAE78
			// (set) Token: 0x06007CE8 RID: 31976 RVA: 0x001FCCAC File Offset: 0x001FAEAC
			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: 0x17002A9D RID: 10909
			// (get) Token: 0x06007CE9 RID: 31977 RVA: 0x001FCCD4 File Offset: 0x001FAED4
			// (set) Token: 0x06007CEA RID: 31978 RVA: 0x001FCD08 File Offset: 0x001FAF08
			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: 0x17002A9E RID: 10910
			// (get) Token: 0x06007CEB RID: 31979 RVA: 0x001FCD30 File Offset: 0x001FAF30
			// (set) Token: 0x06007CEC RID: 31980 RVA: 0x001FCD58 File Offset: 0x001FAF58
			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: 0x17002A9F RID: 10911
			// (get) Token: 0x06007CED RID: 31981 RVA: 0x001FCD7C File Offset: 0x001FAF7C
			// (set) Token: 0x06007CEE RID: 31982 RVA: 0x001FCDB0 File Offset: 0x001FAFB0
			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: 0x04005369 RID: 21353
			private static readonly IntPtr NativeFieldInfoPtr_solver;

			// Token: 0x0400536A RID: 21354
			private static readonly IntPtr NativeFieldInfoPtr_transform;

			// Token: 0x0400536B RID: 21355
			private static readonly IntPtr NativeFieldInfoPtr_rotation;

			// Token: 0x0400536C RID: 21356
			private static readonly IntPtr NativeFieldInfoPtr_leg;

			// Token: 0x0400536D RID: 21357
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_IKSolver_Transform_0;
		}
	}
}
