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

namespace RootMotion.FinalIK
{
	// Token: 0x02000411 RID: 1041
	[Serializable]
	public class Grounding : Il2CppSystem.Object
	{
		// Token: 0x17002AB7 RID: 10935
		// (get) Token: 0x06007CEF RID: 31983 RVA: 0x001FCDD8 File Offset: 0x001FAFD8
		// (set) Token: 0x06007CF0 RID: 31984 RVA: 0x001FCE30 File Offset: 0x001FB030
		public unsafe Il2CppReferenceArray<Grounding.Leg> legs
		{
			[CallerCount(0)]
			get
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.NativeMethodInfoPtr_get_legs_Public_get_Il2CppReferenceArray_1_Leg_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				IntPtr intPtr3 = intPtr;
				return (intPtr3 != 0) ? new Il2CppReferenceArray<Grounding.Leg>(intPtr3) : null;
			}
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 0, XrefRangeEnd = 0, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			set
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				checked
				{
					IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(value);
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.NativeMethodInfoPtr_set_legs_Private_set_Void_Il2CppReferenceArray_1_Leg_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				}
			}
		}

		// Token: 0x17002AB8 RID: 10936
		// (get) Token: 0x06007CF1 RID: 31985 RVA: 0x001FCE8C File Offset: 0x001FB08C
		// (set) Token: 0x06007CF2 RID: 31986 RVA: 0x001FCEE4 File Offset: 0x001FB0E4
		public unsafe Grounding.Pelvis pelvis
		{
			[CallerCount(32)]
			[CachedScanResults(RefRangeStart = 18945, RefRangeEnd = 18977, XrefRangeStart = 18945, XrefRangeEnd = 18977, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			get
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.NativeMethodInfoPtr_get_pelvis_Public_get_Pelvis_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				IntPtr intPtr3 = intPtr;
				return (intPtr3 != 0) ? new Grounding.Pelvis(intPtr3) : null;
			}
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 0, XrefRangeEnd = 0, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			set
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				checked
				{
					IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(value);
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.NativeMethodInfoPtr_set_pelvis_Private_set_Void_Pelvis_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				}
			}
		}

		// Token: 0x17002AB9 RID: 10937
		// (get) Token: 0x06007CF3 RID: 31987 RVA: 0x001FCF40 File Offset: 0x001FB140
		// (set) Token: 0x06007CF4 RID: 31988 RVA: 0x001FCF90 File Offset: 0x001FB190
		public unsafe bool isGrounded
		{
			[CallerCount(0)]
			get
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.NativeMethodInfoPtr_get_isGrounded_Public_get_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}
			[CallerCount(0)]
			set
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				checked
				{
					IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref value;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.NativeMethodInfoPtr_set_isGrounded_Private_set_Void_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				}
			}
		}

		// Token: 0x17002ABA RID: 10938
		// (get) Token: 0x06007CF5 RID: 31989 RVA: 0x001FCFE4 File Offset: 0x001FB1E4
		// (set) Token: 0x06007CF6 RID: 31990 RVA: 0x001FD03C File Offset: 0x001FB23C
		public unsafe Transform root
		{
			[CallerCount(0)]
			get
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.NativeMethodInfoPtr_get_root_Public_get_Transform_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				IntPtr intPtr3 = intPtr;
				return (intPtr3 != 0) ? new Transform(intPtr3) : null;
			}
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 0, XrefRangeEnd = 0, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			set
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				checked
				{
					IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(value);
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.NativeMethodInfoPtr_set_root_Private_set_Void_Transform_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				}
			}
		}

		// Token: 0x17002ABB RID: 10939
		// (get) Token: 0x06007CF7 RID: 31991 RVA: 0x001FD098 File Offset: 0x001FB298
		// (set) Token: 0x06007CF8 RID: 31992 RVA: 0x001FD0E8 File Offset: 0x001FB2E8
		public unsafe RaycastHit rootHit
		{
			[CallerCount(0)]
			get
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.NativeMethodInfoPtr_get_rootHit_Public_get_RaycastHit_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}
			[CallerCount(0)]
			set
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				checked
				{
					IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref value;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.NativeMethodInfoPtr_set_rootHit_Private_set_Void_RaycastHit_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				}
			}
		}

		// Token: 0x17002ABC RID: 10940
		// (get) Token: 0x06007CF9 RID: 31993 RVA: 0x001FD13C File Offset: 0x001FB33C
		public unsafe bool rootGrounded
		{
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 595250, RefRangeEnd = 595252, XrefRangeStart = 595249, XrefRangeEnd = 595250, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			get
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.NativeMethodInfoPtr_get_rootGrounded_Public_get_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}
		}

		// Token: 0x06007CFA RID: 31994 RVA: 0x001FD18C File Offset: 0x001FB38C
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 595272, RefRangeEnd = 595273, XrefRangeStart = 595252, XrefRangeEnd = 595272, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe RaycastHit GetRootHit(float maxDistanceMlp = 10f)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref maxDistanceMlp;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.NativeMethodInfoPtr_GetRootHit_Public_RaycastHit_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}
		}

		// Token: 0x06007CFB RID: 31995 RVA: 0x001FD1F0 File Offset: 0x001FB3F0
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 595273, XrefRangeEnd = 595281, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe bool IsValid(ref string errorMessage)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				ref IntPtr ptr2 = ref *ptr;
				IntPtr intPtr = IL2CPP.ManagedStringToIl2Cpp(errorMessage);
				ptr2 = &intPtr;
				IntPtr intPtr3;
				IntPtr intPtr2 = IL2CPP.il2cpp_runtime_invoke(Grounding.NativeMethodInfoPtr_IsValid_Public_Boolean_byref_String_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr3);
				Il2CppException.RaiseExceptionIfNecessary(intPtr3);
				errorMessage = IL2CPP.Il2CppStringToManaged(intPtr);
				return *IL2CPP.il2cpp_object_unbox(intPtr2);
			}
		}

		// Token: 0x06007CFC RID: 31996 RVA: 0x001FD270 File Offset: 0x001FB470
		[CallerCount(5)]
		[CachedScanResults(RefRangeStart = 595314, RefRangeEnd = 595319, XrefRangeStart = 595281, XrefRangeEnd = 595314, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void Initiate(Transform root, Il2CppReferenceArray<Transform> feet)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(root);
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(feet);
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.NativeMethodInfoPtr_Initiate_Public_Void_Transform_Il2CppReferenceArray_1_Transform_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06007CFD RID: 31997 RVA: 0x001FD2E4 File Offset: 0x001FB4E4
		[CallerCount(5)]
		[CachedScanResults(RefRangeStart = 595334, RefRangeEnd = 595339, XrefRangeStart = 595319, XrefRangeEnd = 595334, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void Update()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.NativeMethodInfoPtr_Update_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06007CFE RID: 31998 RVA: 0x001FD328 File Offset: 0x001FB528
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 595348, RefRangeEnd = 595349, XrefRangeStart = 595339, XrefRangeEnd = 595348, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe Vector3 GetLegsPlaneNormal()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.NativeMethodInfoPtr_GetLegsPlaneNormal_Public_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x06007CFF RID: 31999 RVA: 0x001FD378 File Offset: 0x001FB578
		[CallerCount(5)]
		[CachedScanResults(RefRangeStart = 595353, RefRangeEnd = 595358, XrefRangeStart = 595349, XrefRangeEnd = 595353, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void Reset()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.NativeMethodInfoPtr_Reset_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06007D00 RID: 32000 RVA: 0x001FD3BC File Offset: 0x001FB5BC
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 595358, XrefRangeEnd = 595359, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void LogWarning(string message)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.ManagedStringToIl2Cpp(message);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.NativeMethodInfoPtr_LogWarning_Public_Void_String_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}
		}

		// Token: 0x17002ABD RID: 10941
		// (get) Token: 0x06007D01 RID: 32001 RVA: 0x001FD418 File Offset: 0x001FB618
		public unsafe Vector3 up
		{
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 595363, RefRangeEnd = 595365, XrefRangeStart = 595359, XrefRangeEnd = 595363, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			get
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.NativeMethodInfoPtr_get_up_Public_get_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}
		}

		// Token: 0x06007D02 RID: 32002 RVA: 0x001FD468 File Offset: 0x001FB668
		[CallerCount(5)]
		[CachedScanResults(RefRangeStart = 595366, RefRangeEnd = 595371, XrefRangeStart = 595365, XrefRangeEnd = 595366, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe float GetVerticalOffset(Vector3 p1, Vector3 p2)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref p1;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref p2;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.NativeMethodInfoPtr_GetVerticalOffset_Public_Single_Vector3_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x06007D03 RID: 32003 RVA: 0x001FD4E0 File Offset: 0x001FB6E0
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 595372, RefRangeEnd = 595373, XrefRangeStart = 595371, XrefRangeEnd = 595372, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe Vector3 Flatten(Vector3 v)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref v;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.NativeMethodInfoPtr_Flatten_Public_Vector3_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}
		}

		// Token: 0x17002ABE RID: 10942
		// (get) Token: 0x06007D04 RID: 32004 RVA: 0x001FD544 File Offset: 0x001FB744
		public unsafe bool useRootRotation
		{
			[CallerCount(6)]
			[CachedScanResults(RefRangeStart = 595376, RefRangeEnd = 595382, XrefRangeStart = 595373, XrefRangeEnd = 595376, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			get
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.NativeMethodInfoPtr_get_useRootRotation_Private_get_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}
		}

		// Token: 0x06007D05 RID: 32005 RVA: 0x001FD594 File Offset: 0x001FB794
		[CallerCount(3)]
		[CachedScanResults(RefRangeStart = 595384, RefRangeEnd = 595387, XrefRangeStart = 595382, XrefRangeEnd = 595384, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe Vector3 GetFootCenterOffset()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.NativeMethodInfoPtr_GetFootCenterOffset_Public_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x06007D06 RID: 32006 RVA: 0x001FD5E4 File Offset: 0x001FB7E4
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 595387, XrefRangeEnd = 595388, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe Grounding()
			: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<Grounding>.NativeClassPtr))
		{
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06007D07 RID: 32007 RVA: 0x001FD630 File Offset: 0x001FB830
		// Note: this type is marked as 'beforefieldinit'.
		static Grounding()
		{
			Il2CppClassPointerStore<Grounding>.NativeClassPtr = IL2CPP.GetIl2CppClass("Assembly-CSharp.dll", "RootMotion.FinalIK", "Grounding");
			IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<Grounding>.NativeClassPtr);
			Grounding.NativeFieldInfoPtr_layers = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding>.NativeClassPtr, "layers");
			Grounding.NativeFieldInfoPtr_maxStep = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding>.NativeClassPtr, "maxStep");
			Grounding.NativeFieldInfoPtr_heightOffset = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding>.NativeClassPtr, "heightOffset");
			Grounding.NativeFieldInfoPtr_footSpeed = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding>.NativeClassPtr, "footSpeed");
			Grounding.NativeFieldInfoPtr_footRadius = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding>.NativeClassPtr, "footRadius");
			Grounding.NativeFieldInfoPtr_footCenterOffset = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding>.NativeClassPtr, "footCenterOffset");
			Grounding.NativeFieldInfoPtr_prediction = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding>.NativeClassPtr, "prediction");
			Grounding.NativeFieldInfoPtr_footRotationWeight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding>.NativeClassPtr, "footRotationWeight");
			Grounding.NativeFieldInfoPtr_footRotationSpeed = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding>.NativeClassPtr, "footRotationSpeed");
			Grounding.NativeFieldInfoPtr_maxFootRotationAngle = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding>.NativeClassPtr, "maxFootRotationAngle");
			Grounding.NativeFieldInfoPtr_rotateSolver = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding>.NativeClassPtr, "rotateSolver");
			Grounding.NativeFieldInfoPtr_pelvisSpeed = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding>.NativeClassPtr, "pelvisSpeed");
			Grounding.NativeFieldInfoPtr_pelvisDamper = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding>.NativeClassPtr, "pelvisDamper");
			Grounding.NativeFieldInfoPtr_lowerPelvisWeight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding>.NativeClassPtr, "lowerPelvisWeight");
			Grounding.NativeFieldInfoPtr_liftPelvisWeight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding>.NativeClassPtr, "liftPelvisWeight");
			Grounding.NativeFieldInfoPtr_rootSphereCastRadius = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding>.NativeClassPtr, "rootSphereCastRadius");
			Grounding.NativeFieldInfoPtr_quality = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding>.NativeClassPtr, "quality");
			Grounding.NativeFieldInfoPtr__legs_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding>.NativeClassPtr, "<legs>k__BackingField");
			Grounding.NativeFieldInfoPtr__pelvis_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding>.NativeClassPtr, "<pelvis>k__BackingField");
			Grounding.NativeFieldInfoPtr__isGrounded_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding>.NativeClassPtr, "<isGrounded>k__BackingField");
			Grounding.NativeFieldInfoPtr__root_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding>.NativeClassPtr, "<root>k__BackingField");
			Grounding.NativeFieldInfoPtr__rootHit_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding>.NativeClassPtr, "<rootHit>k__BackingField");
			Grounding.NativeFieldInfoPtr_initiated = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding>.NativeClassPtr, "initiated");
			Grounding.NativeMethodInfoPtr_get_legs_Public_get_Il2CppReferenceArray_1_Leg_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100672687);
			Grounding.NativeMethodInfoPtr_set_legs_Private_set_Void_Il2CppReferenceArray_1_Leg_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100672688);
			Grounding.NativeMethodInfoPtr_get_pelvis_Public_get_Pelvis_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100672689);
			Grounding.NativeMethodInfoPtr_set_pelvis_Private_set_Void_Pelvis_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100672690);
			Grounding.NativeMethodInfoPtr_get_isGrounded_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100672691);
			Grounding.NativeMethodInfoPtr_set_isGrounded_Private_set_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100672692);
			Grounding.NativeMethodInfoPtr_get_root_Public_get_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100672693);
			Grounding.NativeMethodInfoPtr_set_root_Private_set_Void_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100672694);
			Grounding.NativeMethodInfoPtr_get_rootHit_Public_get_RaycastHit_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100672695);
			Grounding.NativeMethodInfoPtr_set_rootHit_Private_set_Void_RaycastHit_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100672696);
			Grounding.NativeMethodInfoPtr_get_rootGrounded_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100672697);
			Grounding.NativeMethodInfoPtr_GetRootHit_Public_RaycastHit_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100672698);
			Grounding.NativeMethodInfoPtr_IsValid_Public_Boolean_byref_String_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100672699);
			Grounding.NativeMethodInfoPtr_Initiate_Public_Void_Transform_Il2CppReferenceArray_1_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100672700);
			Grounding.NativeMethodInfoPtr_Update_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100672701);
			Grounding.NativeMethodInfoPtr_GetLegsPlaneNormal_Public_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100672702);
			Grounding.NativeMethodInfoPtr_Reset_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100672703);
			Grounding.NativeMethodInfoPtr_LogWarning_Public_Void_String_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100672704);
			Grounding.NativeMethodInfoPtr_get_up_Public_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100672705);
			Grounding.NativeMethodInfoPtr_GetVerticalOffset_Public_Single_Vector3_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100672706);
			Grounding.NativeMethodInfoPtr_Flatten_Public_Vector3_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100672707);
			Grounding.NativeMethodInfoPtr_get_useRootRotation_Private_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100672708);
			Grounding.NativeMethodInfoPtr_GetFootCenterOffset_Public_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100672709);
			Grounding.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100672710);
		}

		// Token: 0x06007D08 RID: 32008 RVA: 0x0000A688 File Offset: 0x00008888
		public Grounding(IntPtr pointer)
			: base(pointer)
		{
		}

		// Token: 0x17002AA0 RID: 10912
		// (get) Token: 0x06007D09 RID: 32009 RVA: 0x001FDA0C File Offset: 0x001FBC0C
		// (set) Token: 0x06007D0A RID: 32010 RVA: 0x001FDA34 File Offset: 0x001FBC34
		public unsafe LayerMask layers
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr_layers);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr_layers)) = value;
			}
		}

		// Token: 0x17002AA1 RID: 10913
		// (get) Token: 0x06007D0B RID: 32011 RVA: 0x001FDA58 File Offset: 0x001FBC58
		// (set) Token: 0x06007D0C RID: 32012 RVA: 0x001FDA80 File Offset: 0x001FBC80
		public unsafe float maxStep
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr_maxStep);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr_maxStep)) = value;
			}
		}

		// Token: 0x17002AA2 RID: 10914
		// (get) Token: 0x06007D0D RID: 32013 RVA: 0x001FDAA4 File Offset: 0x001FBCA4
		// (set) Token: 0x06007D0E RID: 32014 RVA: 0x001FDACC File Offset: 0x001FBCCC
		public unsafe float heightOffset
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr_heightOffset);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr_heightOffset)) = value;
			}
		}

		// Token: 0x17002AA3 RID: 10915
		// (get) Token: 0x06007D0F RID: 32015 RVA: 0x001FDAF0 File Offset: 0x001FBCF0
		// (set) Token: 0x06007D10 RID: 32016 RVA: 0x001FDB18 File Offset: 0x001FBD18
		public unsafe float footSpeed
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr_footSpeed);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr_footSpeed)) = value;
			}
		}

		// Token: 0x17002AA4 RID: 10916
		// (get) Token: 0x06007D11 RID: 32017 RVA: 0x001FDB3C File Offset: 0x001FBD3C
		// (set) Token: 0x06007D12 RID: 32018 RVA: 0x001FDB64 File Offset: 0x001FBD64
		public unsafe float footRadius
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr_footRadius);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr_footRadius)) = value;
			}
		}

		// Token: 0x17002AA5 RID: 10917
		// (get) Token: 0x06007D13 RID: 32019 RVA: 0x001FDB88 File Offset: 0x001FBD88
		// (set) Token: 0x06007D14 RID: 32020 RVA: 0x001FDBB0 File Offset: 0x001FBDB0
		public unsafe float footCenterOffset
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr_footCenterOffset);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr_footCenterOffset)) = value;
			}
		}

		// Token: 0x17002AA6 RID: 10918
		// (get) Token: 0x06007D15 RID: 32021 RVA: 0x001FDBD4 File Offset: 0x001FBDD4
		// (set) Token: 0x06007D16 RID: 32022 RVA: 0x001FDBFC File Offset: 0x001FBDFC
		public unsafe float prediction
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr_prediction);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr_prediction)) = value;
			}
		}

		// Token: 0x17002AA7 RID: 10919
		// (get) Token: 0x06007D17 RID: 32023 RVA: 0x001FDC20 File Offset: 0x001FBE20
		// (set) Token: 0x06007D18 RID: 32024 RVA: 0x001FDC48 File Offset: 0x001FBE48
		public unsafe float footRotationWeight
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr_footRotationWeight);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr_footRotationWeight)) = value;
			}
		}

		// Token: 0x17002AA8 RID: 10920
		// (get) Token: 0x06007D19 RID: 32025 RVA: 0x001FDC6C File Offset: 0x001FBE6C
		// (set) Token: 0x06007D1A RID: 32026 RVA: 0x001FDC94 File Offset: 0x001FBE94
		public unsafe float footRotationSpeed
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr_footRotationSpeed);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr_footRotationSpeed)) = value;
			}
		}

		// Token: 0x17002AA9 RID: 10921
		// (get) Token: 0x06007D1B RID: 32027 RVA: 0x001FDCB8 File Offset: 0x001FBEB8
		// (set) Token: 0x06007D1C RID: 32028 RVA: 0x001FDCE0 File Offset: 0x001FBEE0
		public unsafe float maxFootRotationAngle
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr_maxFootRotationAngle);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr_maxFootRotationAngle)) = value;
			}
		}

		// Token: 0x17002AAA RID: 10922
		// (get) Token: 0x06007D1D RID: 32029 RVA: 0x001FDD04 File Offset: 0x001FBF04
		// (set) Token: 0x06007D1E RID: 32030 RVA: 0x001FDD2C File Offset: 0x001FBF2C
		public unsafe bool rotateSolver
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr_rotateSolver);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr_rotateSolver)) = value;
			}
		}

		// Token: 0x17002AAB RID: 10923
		// (get) Token: 0x06007D1F RID: 32031 RVA: 0x001FDD50 File Offset: 0x001FBF50
		// (set) Token: 0x06007D20 RID: 32032 RVA: 0x001FDD78 File Offset: 0x001FBF78
		public unsafe float pelvisSpeed
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr_pelvisSpeed);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr_pelvisSpeed)) = value;
			}
		}

		// Token: 0x17002AAC RID: 10924
		// (get) Token: 0x06007D21 RID: 32033 RVA: 0x001FDD9C File Offset: 0x001FBF9C
		// (set) Token: 0x06007D22 RID: 32034 RVA: 0x001FDDC4 File Offset: 0x001FBFC4
		public unsafe float pelvisDamper
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr_pelvisDamper);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr_pelvisDamper)) = value;
			}
		}

		// Token: 0x17002AAD RID: 10925
		// (get) Token: 0x06007D23 RID: 32035 RVA: 0x001FDDE8 File Offset: 0x001FBFE8
		// (set) Token: 0x06007D24 RID: 32036 RVA: 0x001FDE10 File Offset: 0x001FC010
		public unsafe float lowerPelvisWeight
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr_lowerPelvisWeight);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr_lowerPelvisWeight)) = value;
			}
		}

		// Token: 0x17002AAE RID: 10926
		// (get) Token: 0x06007D25 RID: 32037 RVA: 0x001FDE34 File Offset: 0x001FC034
		// (set) Token: 0x06007D26 RID: 32038 RVA: 0x001FDE5C File Offset: 0x001FC05C
		public unsafe float liftPelvisWeight
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr_liftPelvisWeight);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr_liftPelvisWeight)) = value;
			}
		}

		// Token: 0x17002AAF RID: 10927
		// (get) Token: 0x06007D27 RID: 32039 RVA: 0x001FDE80 File Offset: 0x001FC080
		// (set) Token: 0x06007D28 RID: 32040 RVA: 0x001FDEA8 File Offset: 0x001FC0A8
		public unsafe float rootSphereCastRadius
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr_rootSphereCastRadius);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr_rootSphereCastRadius)) = value;
			}
		}

		// Token: 0x17002AB0 RID: 10928
		// (get) Token: 0x06007D29 RID: 32041 RVA: 0x001FDECC File Offset: 0x001FC0CC
		// (set) Token: 0x06007D2A RID: 32042 RVA: 0x001FDEF4 File Offset: 0x001FC0F4
		public unsafe Grounding.Quality quality
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr_quality);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr_quality)) = value;
			}
		}

		// Token: 0x17002AB1 RID: 10929
		// (get) Token: 0x06007D2B RID: 32043 RVA: 0x001FDF18 File Offset: 0x001FC118
		// (set) Token: 0x06007D2C RID: 32044 RVA: 0x001FDF4C File Offset: 0x001FC14C
		public unsafe Il2CppReferenceArray<Grounding.Leg> _legs_k__BackingField
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr__legs_k__BackingField);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new Il2CppReferenceArray<Grounding.Leg>(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr__legs_k__BackingField), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002AB2 RID: 10930
		// (get) Token: 0x06007D2D RID: 32045 RVA: 0x001FDF74 File Offset: 0x001FC174
		// (set) Token: 0x06007D2E RID: 32046 RVA: 0x001FDFA8 File Offset: 0x001FC1A8
		public unsafe Grounding.Pelvis _pelvis_k__BackingField
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr__pelvis_k__BackingField);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new Grounding.Pelvis(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr__pelvis_k__BackingField), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002AB3 RID: 10931
		// (get) Token: 0x06007D2F RID: 32047 RVA: 0x001FDFD0 File Offset: 0x001FC1D0
		// (set) Token: 0x06007D30 RID: 32048 RVA: 0x001FDFF8 File Offset: 0x001FC1F8
		public unsafe bool _isGrounded_k__BackingField
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr__isGrounded_k__BackingField);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr__isGrounded_k__BackingField)) = value;
			}
		}

		// Token: 0x17002AB4 RID: 10932
		// (get) Token: 0x06007D31 RID: 32049 RVA: 0x001FE01C File Offset: 0x001FC21C
		// (set) Token: 0x06007D32 RID: 32050 RVA: 0x001FE050 File Offset: 0x001FC250
		public unsafe Transform _root_k__BackingField
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr__root_k__BackingField);
				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(Grounding.NativeFieldInfoPtr__root_k__BackingField), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002AB5 RID: 10933
		// (get) Token: 0x06007D33 RID: 32051 RVA: 0x001FE078 File Offset: 0x001FC278
		// (set) Token: 0x06007D34 RID: 32052 RVA: 0x001FE0A0 File Offset: 0x001FC2A0
		public unsafe RaycastHit _rootHit_k__BackingField
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr__rootHit_k__BackingField);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr__rootHit_k__BackingField)) = value;
			}
		}

		// Token: 0x17002AB6 RID: 10934
		// (get) Token: 0x06007D35 RID: 32053 RVA: 0x001FE0C4 File Offset: 0x001FC2C4
		// (set) Token: 0x06007D36 RID: 32054 RVA: 0x001FE0EC File Offset: 0x001FC2EC
		public unsafe bool initiated
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr_initiated);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.NativeFieldInfoPtr_initiated)) = value;
			}
		}

		// Token: 0x0400536E RID: 21358
		private static readonly IntPtr NativeFieldInfoPtr_layers;

		// Token: 0x0400536F RID: 21359
		private static readonly IntPtr NativeFieldInfoPtr_maxStep;

		// Token: 0x04005370 RID: 21360
		private static readonly IntPtr NativeFieldInfoPtr_heightOffset;

		// Token: 0x04005371 RID: 21361
		private static readonly IntPtr NativeFieldInfoPtr_footSpeed;

		// Token: 0x04005372 RID: 21362
		private static readonly IntPtr NativeFieldInfoPtr_footRadius;

		// Token: 0x04005373 RID: 21363
		private static readonly IntPtr NativeFieldInfoPtr_footCenterOffset;

		// Token: 0x04005374 RID: 21364
		private static readonly IntPtr NativeFieldInfoPtr_prediction;

		// Token: 0x04005375 RID: 21365
		private static readonly IntPtr NativeFieldInfoPtr_footRotationWeight;

		// Token: 0x04005376 RID: 21366
		private static readonly IntPtr NativeFieldInfoPtr_footRotationSpeed;

		// Token: 0x04005377 RID: 21367
		private static readonly IntPtr NativeFieldInfoPtr_maxFootRotationAngle;

		// Token: 0x04005378 RID: 21368
		private static readonly IntPtr NativeFieldInfoPtr_rotateSolver;

		// Token: 0x04005379 RID: 21369
		private static readonly IntPtr NativeFieldInfoPtr_pelvisSpeed;

		// Token: 0x0400537A RID: 21370
		private static readonly IntPtr NativeFieldInfoPtr_pelvisDamper;

		// Token: 0x0400537B RID: 21371
		private static readonly IntPtr NativeFieldInfoPtr_lowerPelvisWeight;

		// Token: 0x0400537C RID: 21372
		private static readonly IntPtr NativeFieldInfoPtr_liftPelvisWeight;

		// Token: 0x0400537D RID: 21373
		private static readonly IntPtr NativeFieldInfoPtr_rootSphereCastRadius;

		// Token: 0x0400537E RID: 21374
		private static readonly IntPtr NativeFieldInfoPtr_quality;

		// Token: 0x0400537F RID: 21375
		private static readonly IntPtr NativeFieldInfoPtr__legs_k__BackingField;

		// Token: 0x04005380 RID: 21376
		private static readonly IntPtr NativeFieldInfoPtr__pelvis_k__BackingField;

		// Token: 0x04005381 RID: 21377
		private static readonly IntPtr NativeFieldInfoPtr__isGrounded_k__BackingField;

		// Token: 0x04005382 RID: 21378
		private static readonly IntPtr NativeFieldInfoPtr__root_k__BackingField;

		// Token: 0x04005383 RID: 21379
		private static readonly IntPtr NativeFieldInfoPtr__rootHit_k__BackingField;

		// Token: 0x04005384 RID: 21380
		private static readonly IntPtr NativeFieldInfoPtr_initiated;

		// Token: 0x04005385 RID: 21381
		private static readonly IntPtr NativeMethodInfoPtr_get_legs_Public_get_Il2CppReferenceArray_1_Leg_0;

		// Token: 0x04005386 RID: 21382
		private static readonly IntPtr NativeMethodInfoPtr_set_legs_Private_set_Void_Il2CppReferenceArray_1_Leg_0;

		// Token: 0x04005387 RID: 21383
		private static readonly IntPtr NativeMethodInfoPtr_get_pelvis_Public_get_Pelvis_0;

		// Token: 0x04005388 RID: 21384
		private static readonly IntPtr NativeMethodInfoPtr_set_pelvis_Private_set_Void_Pelvis_0;

		// Token: 0x04005389 RID: 21385
		private static readonly IntPtr NativeMethodInfoPtr_get_isGrounded_Public_get_Boolean_0;

		// Token: 0x0400538A RID: 21386
		private static readonly IntPtr NativeMethodInfoPtr_set_isGrounded_Private_set_Void_Boolean_0;

		// Token: 0x0400538B RID: 21387
		private static readonly IntPtr NativeMethodInfoPtr_get_root_Public_get_Transform_0;

		// Token: 0x0400538C RID: 21388
		private static readonly IntPtr NativeMethodInfoPtr_set_root_Private_set_Void_Transform_0;

		// Token: 0x0400538D RID: 21389
		private static readonly IntPtr NativeMethodInfoPtr_get_rootHit_Public_get_RaycastHit_0;

		// Token: 0x0400538E RID: 21390
		private static readonly IntPtr NativeMethodInfoPtr_set_rootHit_Private_set_Void_RaycastHit_0;

		// Token: 0x0400538F RID: 21391
		private static readonly IntPtr NativeMethodInfoPtr_get_rootGrounded_Public_get_Boolean_0;

		// Token: 0x04005390 RID: 21392
		private static readonly IntPtr NativeMethodInfoPtr_GetRootHit_Public_RaycastHit_Single_0;

		// Token: 0x04005391 RID: 21393
		private static readonly IntPtr NativeMethodInfoPtr_IsValid_Public_Boolean_byref_String_0;

		// Token: 0x04005392 RID: 21394
		private static readonly IntPtr NativeMethodInfoPtr_Initiate_Public_Void_Transform_Il2CppReferenceArray_1_Transform_0;

		// Token: 0x04005393 RID: 21395
		private static readonly IntPtr NativeMethodInfoPtr_Update_Public_Void_0;

		// Token: 0x04005394 RID: 21396
		private static readonly IntPtr NativeMethodInfoPtr_GetLegsPlaneNormal_Public_Vector3_0;

		// Token: 0x04005395 RID: 21397
		private static readonly IntPtr NativeMethodInfoPtr_Reset_Public_Void_0;

		// Token: 0x04005396 RID: 21398
		private static readonly IntPtr NativeMethodInfoPtr_LogWarning_Public_Void_String_0;

		// Token: 0x04005397 RID: 21399
		private static readonly IntPtr NativeMethodInfoPtr_get_up_Public_get_Vector3_0;

		// Token: 0x04005398 RID: 21400
		private static readonly IntPtr NativeMethodInfoPtr_GetVerticalOffset_Public_Single_Vector3_Vector3_0;

		// Token: 0x04005399 RID: 21401
		private static readonly IntPtr NativeMethodInfoPtr_Flatten_Public_Vector3_Vector3_0;

		// Token: 0x0400539A RID: 21402
		private static readonly IntPtr NativeMethodInfoPtr_get_useRootRotation_Private_get_Boolean_0;

		// Token: 0x0400539B RID: 21403
		private static readonly IntPtr NativeMethodInfoPtr_GetFootCenterOffset_Public_Vector3_0;

		// Token: 0x0400539C RID: 21404
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

		// Token: 0x02000412 RID: 1042
		[Serializable]
		public enum Quality
		{
			// Token: 0x0400539E RID: 21406
			Fastest,
			// Token: 0x0400539F RID: 21407
			Simple,
			// Token: 0x040053A0 RID: 21408
			Best
		}

		// Token: 0x02000413 RID: 1043
		public class Leg : Il2CppSystem.Object
		{
			// Token: 0x17002AD0 RID: 10960
			// (get) Token: 0x06007D37 RID: 32055 RVA: 0x001FE110 File Offset: 0x001FC310
			// (set) Token: 0x06007D38 RID: 32056 RVA: 0x001FE160 File Offset: 0x001FC360
			public unsafe bool isGrounded
			{
				[CallerCount(1)]
				[CachedScanResults(RefRangeStart = 6570, RefRangeEnd = 6571, XrefRangeStart = 6570, XrefRangeEnd = 6571, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.Leg.NativeMethodInfoPtr_get_isGrounded_Public_get_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
				[CallerCount(0)]
				set
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					checked
					{
						IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
						*ptr = ref value;
						IntPtr intPtr2;
						IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.Leg.NativeMethodInfoPtr_set_isGrounded_Private_set_Void_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
						Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					}
				}
			}

			// Token: 0x17002AD1 RID: 10961
			// (get) Token: 0x06007D39 RID: 32057 RVA: 0x001FE1B4 File Offset: 0x001FC3B4
			// (set) Token: 0x06007D3A RID: 32058 RVA: 0x001FE204 File Offset: 0x001FC404
			public unsafe Vector3 IKPosition
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.Leg.NativeMethodInfoPtr_get_IKPosition_Public_get_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
				[CallerCount(0)]
				set
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					checked
					{
						IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
						*ptr = ref value;
						IntPtr intPtr2;
						IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.Leg.NativeMethodInfoPtr_set_IKPosition_Private_set_Void_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
						Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					}
				}
			}

			// Token: 0x17002AD2 RID: 10962
			// (get) Token: 0x06007D3B RID: 32059 RVA: 0x001FE258 File Offset: 0x001FC458
			// (set) Token: 0x06007D3C RID: 32060 RVA: 0x001FE2A8 File Offset: 0x001FC4A8
			public unsafe bool initiated
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.Leg.NativeMethodInfoPtr_get_initiated_Public_get_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
				[CallerCount(0)]
				set
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					checked
					{
						IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
						*ptr = ref value;
						IntPtr intPtr2;
						IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.Leg.NativeMethodInfoPtr_set_initiated_Private_set_Void_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
						Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					}
				}
			}

			// Token: 0x17002AD3 RID: 10963
			// (get) Token: 0x06007D3D RID: 32061 RVA: 0x001FE2FC File Offset: 0x001FC4FC
			// (set) Token: 0x06007D3E RID: 32062 RVA: 0x001FE34C File Offset: 0x001FC54C
			public unsafe float heightFromGround
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.Leg.NativeMethodInfoPtr_get_heightFromGround_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
				[CallerCount(1)]
				[CachedScanResults(RefRangeStart = 218234, RefRangeEnd = 218235, XrefRangeStart = 218234, XrefRangeEnd = 218235, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
				set
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					checked
					{
						IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
						*ptr = ref value;
						IntPtr intPtr2;
						IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.Leg.NativeMethodInfoPtr_set_heightFromGround_Private_set_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
						Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					}
				}
			}

			// Token: 0x17002AD4 RID: 10964
			// (get) Token: 0x06007D3F RID: 32063 RVA: 0x001FE3A0 File Offset: 0x001FC5A0
			// (set) Token: 0x06007D40 RID: 32064 RVA: 0x001FE3F0 File Offset: 0x001FC5F0
			public unsafe Vector3 velocity
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.Leg.NativeMethodInfoPtr_get_velocity_Public_get_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
				[CallerCount(0)]
				set
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					checked
					{
						IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
						*ptr = ref value;
						IntPtr intPtr2;
						IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.Leg.NativeMethodInfoPtr_set_velocity_Private_set_Void_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
						Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					}
				}
			}

			// Token: 0x17002AD5 RID: 10965
			// (get) Token: 0x06007D41 RID: 32065 RVA: 0x001FE444 File Offset: 0x001FC644
			// (set) Token: 0x06007D42 RID: 32066 RVA: 0x001FE49C File Offset: 0x001FC69C
			public unsafe Transform transform
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.Leg.NativeMethodInfoPtr_get_transform_Public_get_Transform_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					IntPtr intPtr3 = intPtr;
					return (intPtr3 != 0) ? new Transform(intPtr3) : null;
				}
				[CallerCount(0)]
				[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 0, XrefRangeEnd = 0, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
				set
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					checked
					{
						IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
						*ptr = IL2CPP.Il2CppObjectBaseToPtr(value);
						IntPtr intPtr2;
						IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.Leg.NativeMethodInfoPtr_set_transform_Private_set_Void_Transform_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
						Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					}
				}
			}

			// Token: 0x17002AD6 RID: 10966
			// (get) Token: 0x06007D43 RID: 32067 RVA: 0x001FE4F8 File Offset: 0x001FC6F8
			// (set) Token: 0x06007D44 RID: 32068 RVA: 0x001FE548 File Offset: 0x001FC748
			public unsafe float IKOffset
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.Leg.NativeMethodInfoPtr_get_IKOffset_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
				[CallerCount(2)]
				[CachedScanResults(RefRangeStart = 218263, RefRangeEnd = 218265, XrefRangeStart = 218263, XrefRangeEnd = 218265, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
				set
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					checked
					{
						IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
						*ptr = ref value;
						IntPtr intPtr2;
						IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.Leg.NativeMethodInfoPtr_set_IKOffset_Private_set_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
						Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					}
				}
			}

			// Token: 0x06007D45 RID: 32069 RVA: 0x001FE59C File Offset: 0x001FC79C
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 595096, RefRangeEnd = 595097, XrefRangeStart = 595089, XrefRangeEnd = 595096, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void Initiate(Grounding grounding, Transform transform)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(grounding);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(transform);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.Leg.NativeMethodInfoPtr_Initiate_Public_Void_Grounding_Transform_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06007D46 RID: 32070 RVA: 0x001FE610 File Offset: 0x001FC810
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 595097, XrefRangeEnd = 595099, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void OnEnable()
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.Leg.NativeMethodInfoPtr_OnEnable_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06007D47 RID: 32071 RVA: 0x001FE654 File Offset: 0x001FC854
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 595103, RefRangeEnd = 595104, XrefRangeStart = 595099, XrefRangeEnd = 595103, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void Reset()
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.Leg.NativeMethodInfoPtr_Reset_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06007D48 RID: 32072 RVA: 0x001FE698 File Offset: 0x001FC898
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 595161, RefRangeEnd = 595162, XrefRangeStart = 595104, XrefRangeEnd = 595161, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void Process()
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.Leg.NativeMethodInfoPtr_Process_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x17002AD7 RID: 10967
			// (get) Token: 0x06007D49 RID: 32073 RVA: 0x001FE6DC File Offset: 0x001FC8DC
			public unsafe float stepHeightFromGround
			{
				[CallerCount(0)]
				[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 595162, XrefRangeEnd = 595164, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.Leg.NativeMethodInfoPtr_get_stepHeightFromGround_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
			}

			// Token: 0x06007D4A RID: 32074 RVA: 0x001FE72C File Offset: 0x001FC92C
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 595175, RefRangeEnd = 595176, XrefRangeStart = 595164, XrefRangeEnd = 595175, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe RaycastHit GetCapsuleHit(Vector3 offsetFromHeel)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				checked
				{
					IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref offsetFromHeel;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.Leg.NativeMethodInfoPtr_GetCapsuleHit_Private_RaycastHit_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
			}

			// Token: 0x06007D4B RID: 32075 RVA: 0x001FE790 File Offset: 0x001FC990
			[CallerCount(5)]
			[CachedScanResults(RefRangeStart = 595181, RefRangeEnd = 595186, XrefRangeStart = 595176, XrefRangeEnd = 595181, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe RaycastHit GetRaycastHit(Vector3 offsetFromHeel)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				checked
				{
					IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref offsetFromHeel;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.Leg.NativeMethodInfoPtr_GetRaycastHit_Private_RaycastHit_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
			}

			// Token: 0x06007D4C RID: 32076 RVA: 0x001FE7F4 File Offset: 0x001FC9F4
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 595186, XrefRangeEnd = 595187, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe Vector3 RotateNormal(Vector3 normal)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				checked
				{
					IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref normal;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.Leg.NativeMethodInfoPtr_RotateNormal_Private_Vector3_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
			}

			// Token: 0x06007D4D RID: 32077 RVA: 0x001FE858 File Offset: 0x001FCA58
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 595187, XrefRangeEnd = 595191, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void SetFootToPoint(Vector3 normal, Vector3 point)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref normal;
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref point;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.Leg.NativeMethodInfoPtr_SetFootToPoint_Private_Void_Vector3_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06007D4E RID: 32078 RVA: 0x001FE8C0 File Offset: 0x001FCAC0
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 595199, RefRangeEnd = 595201, XrefRangeStart = 595191, XrefRangeEnd = 595199, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void SetFootToPlane(Vector3 planeNormal, Vector3 planePoint, Vector3 heelHitPoint)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref planeNormal;
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref planePoint;
				ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref heelHitPoint;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.Leg.NativeMethodInfoPtr_SetFootToPlane_Private_Void_Vector3_Vector3_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06007D4F RID: 32079 RVA: 0x001FE93C File Offset: 0x001FCB3C
			[CallerCount(4)]
			[CachedScanResults(RefRangeStart = 595206, RefRangeEnd = 595210, XrefRangeStart = 595201, XrefRangeEnd = 595206, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe float GetHeightFromGround(Vector3 hitPoint)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				checked
				{
					IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref hitPoint;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.Leg.NativeMethodInfoPtr_GetHeightFromGround_Private_Single_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
			}

			// Token: 0x06007D50 RID: 32080 RVA: 0x001FE9A0 File Offset: 0x001FCBA0
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 595210, XrefRangeEnd = 595216, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void RotateFoot()
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.Leg.NativeMethodInfoPtr_RotateFoot_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06007D51 RID: 32081 RVA: 0x001FE9E4 File Offset: 0x001FCBE4
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 595216, XrefRangeEnd = 595218, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe Quaternion GetRotationOffsetTarget()
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.Leg.NativeMethodInfoPtr_GetRotationOffsetTarget_Private_Quaternion_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}

			// Token: 0x17002AD8 RID: 10968
			// (get) Token: 0x06007D52 RID: 32082 RVA: 0x001FEA34 File Offset: 0x001FCC34
			public unsafe float rootYOffset
			{
				[CallerCount(0)]
				[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 595218, XrefRangeEnd = 595221, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.Leg.NativeMethodInfoPtr_get_rootYOffset_Private_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
			}

			// Token: 0x06007D53 RID: 32083 RVA: 0x001FEA84 File Offset: 0x001FCC84
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 595224, RefRangeEnd = 595225, XrefRangeStart = 595221, XrefRangeEnd = 595224, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe Leg()
				: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr))
			{
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.Leg.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06007D54 RID: 32084 RVA: 0x001FEAD0 File Offset: 0x001FCCD0
			// Note: this type is marked as 'beforefieldinit'.
			static Leg()
			{
				Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<Grounding>.NativeClassPtr, "Leg");
				IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr);
				Grounding.Leg.NativeFieldInfoPtr__isGrounded_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, "<isGrounded>k__BackingField");
				Grounding.Leg.NativeFieldInfoPtr__IKPosition_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, "<IKPosition>k__BackingField");
				Grounding.Leg.NativeFieldInfoPtr_rotationOffset = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, "rotationOffset");
				Grounding.Leg.NativeFieldInfoPtr__initiated_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, "<initiated>k__BackingField");
				Grounding.Leg.NativeFieldInfoPtr__heightFromGround_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, "<heightFromGround>k__BackingField");
				Grounding.Leg.NativeFieldInfoPtr__velocity_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, "<velocity>k__BackingField");
				Grounding.Leg.NativeFieldInfoPtr__transform_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, "<transform>k__BackingField");
				Grounding.Leg.NativeFieldInfoPtr__IKOffset_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, "<IKOffset>k__BackingField");
				Grounding.Leg.NativeFieldInfoPtr_invertFootCenter = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, "invertFootCenter");
				Grounding.Leg.NativeFieldInfoPtr_grounding = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, "grounding");
				Grounding.Leg.NativeFieldInfoPtr_lastTime = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, "lastTime");
				Grounding.Leg.NativeFieldInfoPtr_deltaTime = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, "deltaTime");
				Grounding.Leg.NativeFieldInfoPtr_lastPosition = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, "lastPosition");
				Grounding.Leg.NativeFieldInfoPtr_toHitNormal = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, "toHitNormal");
				Grounding.Leg.NativeFieldInfoPtr_r = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, "r");
				Grounding.Leg.NativeFieldInfoPtr_heelHit = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, "heelHit");
				Grounding.Leg.NativeFieldInfoPtr_up = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, "up");
				Grounding.Leg.NativeMethodInfoPtr_get_isGrounded_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100672711);
				Grounding.Leg.NativeMethodInfoPtr_set_isGrounded_Private_set_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100672712);
				Grounding.Leg.NativeMethodInfoPtr_get_IKPosition_Public_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100672713);
				Grounding.Leg.NativeMethodInfoPtr_set_IKPosition_Private_set_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100672714);
				Grounding.Leg.NativeMethodInfoPtr_get_initiated_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100672715);
				Grounding.Leg.NativeMethodInfoPtr_set_initiated_Private_set_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100672716);
				Grounding.Leg.NativeMethodInfoPtr_get_heightFromGround_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100672717);
				Grounding.Leg.NativeMethodInfoPtr_set_heightFromGround_Private_set_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100672718);
				Grounding.Leg.NativeMethodInfoPtr_get_velocity_Public_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100672719);
				Grounding.Leg.NativeMethodInfoPtr_set_velocity_Private_set_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100672720);
				Grounding.Leg.NativeMethodInfoPtr_get_transform_Public_get_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100672721);
				Grounding.Leg.NativeMethodInfoPtr_set_transform_Private_set_Void_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100672722);
				Grounding.Leg.NativeMethodInfoPtr_get_IKOffset_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100672723);
				Grounding.Leg.NativeMethodInfoPtr_set_IKOffset_Private_set_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100672724);
				Grounding.Leg.NativeMethodInfoPtr_Initiate_Public_Void_Grounding_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100672725);
				Grounding.Leg.NativeMethodInfoPtr_OnEnable_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100672726);
				Grounding.Leg.NativeMethodInfoPtr_Reset_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100672727);
				Grounding.Leg.NativeMethodInfoPtr_Process_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100672728);
				Grounding.Leg.NativeMethodInfoPtr_get_stepHeightFromGround_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100672729);
				Grounding.Leg.NativeMethodInfoPtr_GetCapsuleHit_Private_RaycastHit_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100672730);
				Grounding.Leg.NativeMethodInfoPtr_GetRaycastHit_Private_RaycastHit_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100672731);
				Grounding.Leg.NativeMethodInfoPtr_RotateNormal_Private_Vector3_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100672732);
				Grounding.Leg.NativeMethodInfoPtr_SetFootToPoint_Private_Void_Vector3_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100672733);
				Grounding.Leg.NativeMethodInfoPtr_SetFootToPlane_Private_Void_Vector3_Vector3_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100672734);
				Grounding.Leg.NativeMethodInfoPtr_GetHeightFromGround_Private_Single_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100672735);
				Grounding.Leg.NativeMethodInfoPtr_RotateFoot_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100672736);
				Grounding.Leg.NativeMethodInfoPtr_GetRotationOffsetTarget_Private_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100672737);
				Grounding.Leg.NativeMethodInfoPtr_get_rootYOffset_Private_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100672738);
				Grounding.Leg.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100672739);
			}

			// Token: 0x06007D55 RID: 32085 RVA: 0x0000A688 File Offset: 0x00008888
			public Leg(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002ABF RID: 10943
			// (get) Token: 0x06007D56 RID: 32086 RVA: 0x001FEE94 File Offset: 0x001FD094
			// (set) Token: 0x06007D57 RID: 32087 RVA: 0x001FEEBC File Offset: 0x001FD0BC
			public unsafe bool _isGrounded_k__BackingField
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Leg.NativeFieldInfoPtr__isGrounded_k__BackingField);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Leg.NativeFieldInfoPtr__isGrounded_k__BackingField)) = value;
				}
			}

			// Token: 0x17002AC0 RID: 10944
			// (get) Token: 0x06007D58 RID: 32088 RVA: 0x001FEEE0 File Offset: 0x001FD0E0
			// (set) Token: 0x06007D59 RID: 32089 RVA: 0x001FEF08 File Offset: 0x001FD108
			public unsafe Vector3 _IKPosition_k__BackingField
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Leg.NativeFieldInfoPtr__IKPosition_k__BackingField);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Leg.NativeFieldInfoPtr__IKPosition_k__BackingField)) = value;
				}
			}

			// Token: 0x17002AC1 RID: 10945
			// (get) Token: 0x06007D5A RID: 32090 RVA: 0x001FEF2C File Offset: 0x001FD12C
			// (set) Token: 0x06007D5B RID: 32091 RVA: 0x001FEF54 File Offset: 0x001FD154
			public unsafe Quaternion rotationOffset
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Leg.NativeFieldInfoPtr_rotationOffset);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Leg.NativeFieldInfoPtr_rotationOffset)) = value;
				}
			}

			// Token: 0x17002AC2 RID: 10946
			// (get) Token: 0x06007D5C RID: 32092 RVA: 0x001FEF78 File Offset: 0x001FD178
			// (set) Token: 0x06007D5D RID: 32093 RVA: 0x001FEFA0 File Offset: 0x001FD1A0
			public unsafe bool _initiated_k__BackingField
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Leg.NativeFieldInfoPtr__initiated_k__BackingField);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Leg.NativeFieldInfoPtr__initiated_k__BackingField)) = value;
				}
			}

			// Token: 0x17002AC3 RID: 10947
			// (get) Token: 0x06007D5E RID: 32094 RVA: 0x001FEFC4 File Offset: 0x001FD1C4
			// (set) Token: 0x06007D5F RID: 32095 RVA: 0x001FEFEC File Offset: 0x001FD1EC
			public unsafe float _heightFromGround_k__BackingField
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Leg.NativeFieldInfoPtr__heightFromGround_k__BackingField);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Leg.NativeFieldInfoPtr__heightFromGround_k__BackingField)) = value;
				}
			}

			// Token: 0x17002AC4 RID: 10948
			// (get) Token: 0x06007D60 RID: 32096 RVA: 0x001FF010 File Offset: 0x001FD210
			// (set) Token: 0x06007D61 RID: 32097 RVA: 0x001FF038 File Offset: 0x001FD238
			public unsafe Vector3 _velocity_k__BackingField
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Leg.NativeFieldInfoPtr__velocity_k__BackingField);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Leg.NativeFieldInfoPtr__velocity_k__BackingField)) = value;
				}
			}

			// Token: 0x17002AC5 RID: 10949
			// (get) Token: 0x06007D62 RID: 32098 RVA: 0x001FF05C File Offset: 0x001FD25C
			// (set) Token: 0x06007D63 RID: 32099 RVA: 0x001FF090 File Offset: 0x001FD290
			public unsafe Transform _transform_k__BackingField
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Leg.NativeFieldInfoPtr__transform_k__BackingField);
					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(Grounding.Leg.NativeFieldInfoPtr__transform_k__BackingField), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x17002AC6 RID: 10950
			// (get) Token: 0x06007D64 RID: 32100 RVA: 0x001FF0B8 File Offset: 0x001FD2B8
			// (set) Token: 0x06007D65 RID: 32101 RVA: 0x001FF0E0 File Offset: 0x001FD2E0
			public unsafe float _IKOffset_k__BackingField
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Leg.NativeFieldInfoPtr__IKOffset_k__BackingField);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Leg.NativeFieldInfoPtr__IKOffset_k__BackingField)) = value;
				}
			}

			// Token: 0x17002AC7 RID: 10951
			// (get) Token: 0x06007D66 RID: 32102 RVA: 0x001FF104 File Offset: 0x001FD304
			// (set) Token: 0x06007D67 RID: 32103 RVA: 0x001FF12C File Offset: 0x001FD32C
			public unsafe bool invertFootCenter
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Leg.NativeFieldInfoPtr_invertFootCenter);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Leg.NativeFieldInfoPtr_invertFootCenter)) = value;
				}
			}

			// Token: 0x17002AC8 RID: 10952
			// (get) Token: 0x06007D68 RID: 32104 RVA: 0x001FF150 File Offset: 0x001FD350
			// (set) Token: 0x06007D69 RID: 32105 RVA: 0x001FF184 File Offset: 0x001FD384
			public unsafe Grounding grounding
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Leg.NativeFieldInfoPtr_grounding);
					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(Grounding.Leg.NativeFieldInfoPtr_grounding), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x17002AC9 RID: 10953
			// (get) Token: 0x06007D6A RID: 32106 RVA: 0x001FF1AC File Offset: 0x001FD3AC
			// (set) Token: 0x06007D6B RID: 32107 RVA: 0x001FF1D4 File Offset: 0x001FD3D4
			public unsafe float lastTime
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Leg.NativeFieldInfoPtr_lastTime);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Leg.NativeFieldInfoPtr_lastTime)) = value;
				}
			}

			// Token: 0x17002ACA RID: 10954
			// (get) Token: 0x06007D6C RID: 32108 RVA: 0x001FF1F8 File Offset: 0x001FD3F8
			// (set) Token: 0x06007D6D RID: 32109 RVA: 0x001FF220 File Offset: 0x001FD420
			public unsafe float deltaTime
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Leg.NativeFieldInfoPtr_deltaTime);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Leg.NativeFieldInfoPtr_deltaTime)) = value;
				}
			}

			// Token: 0x17002ACB RID: 10955
			// (get) Token: 0x06007D6E RID: 32110 RVA: 0x001FF244 File Offset: 0x001FD444
			// (set) Token: 0x06007D6F RID: 32111 RVA: 0x001FF26C File Offset: 0x001FD46C
			public unsafe Vector3 lastPosition
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Leg.NativeFieldInfoPtr_lastPosition);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Leg.NativeFieldInfoPtr_lastPosition)) = value;
				}
			}

			// Token: 0x17002ACC RID: 10956
			// (get) Token: 0x06007D70 RID: 32112 RVA: 0x001FF290 File Offset: 0x001FD490
			// (set) Token: 0x06007D71 RID: 32113 RVA: 0x001FF2B8 File Offset: 0x001FD4B8
			public unsafe Quaternion toHitNormal
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Leg.NativeFieldInfoPtr_toHitNormal);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Leg.NativeFieldInfoPtr_toHitNormal)) = value;
				}
			}

			// Token: 0x17002ACD RID: 10957
			// (get) Token: 0x06007D72 RID: 32114 RVA: 0x001FF2DC File Offset: 0x001FD4DC
			// (set) Token: 0x06007D73 RID: 32115 RVA: 0x001FF304 File Offset: 0x001FD504
			public unsafe Quaternion r
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Leg.NativeFieldInfoPtr_r);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Leg.NativeFieldInfoPtr_r)) = value;
				}
			}

			// Token: 0x17002ACE RID: 10958
			// (get) Token: 0x06007D74 RID: 32116 RVA: 0x001FF328 File Offset: 0x001FD528
			// (set) Token: 0x06007D75 RID: 32117 RVA: 0x001FF350 File Offset: 0x001FD550
			public unsafe RaycastHit heelHit
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Leg.NativeFieldInfoPtr_heelHit);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Leg.NativeFieldInfoPtr_heelHit)) = value;
				}
			}

			// Token: 0x17002ACF RID: 10959
			// (get) Token: 0x06007D76 RID: 32118 RVA: 0x001FF374 File Offset: 0x001FD574
			// (set) Token: 0x06007D77 RID: 32119 RVA: 0x001FF39C File Offset: 0x001FD59C
			public unsafe Vector3 up
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Leg.NativeFieldInfoPtr_up);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Leg.NativeFieldInfoPtr_up)) = value;
				}
			}

			// Token: 0x040053A1 RID: 21409
			private static readonly IntPtr NativeFieldInfoPtr__isGrounded_k__BackingField;

			// Token: 0x040053A2 RID: 21410
			private static readonly IntPtr NativeFieldInfoPtr__IKPosition_k__BackingField;

			// Token: 0x040053A3 RID: 21411
			private static readonly IntPtr NativeFieldInfoPtr_rotationOffset;

			// Token: 0x040053A4 RID: 21412
			private static readonly IntPtr NativeFieldInfoPtr__initiated_k__BackingField;

			// Token: 0x040053A5 RID: 21413
			private static readonly IntPtr NativeFieldInfoPtr__heightFromGround_k__BackingField;

			// Token: 0x040053A6 RID: 21414
			private static readonly IntPtr NativeFieldInfoPtr__velocity_k__BackingField;

			// Token: 0x040053A7 RID: 21415
			private static readonly IntPtr NativeFieldInfoPtr__transform_k__BackingField;

			// Token: 0x040053A8 RID: 21416
			private static readonly IntPtr NativeFieldInfoPtr__IKOffset_k__BackingField;

			// Token: 0x040053A9 RID: 21417
			private static readonly IntPtr NativeFieldInfoPtr_invertFootCenter;

			// Token: 0x040053AA RID: 21418
			private static readonly IntPtr NativeFieldInfoPtr_grounding;

			// Token: 0x040053AB RID: 21419
			private static readonly IntPtr NativeFieldInfoPtr_lastTime;

			// Token: 0x040053AC RID: 21420
			private static readonly IntPtr NativeFieldInfoPtr_deltaTime;

			// Token: 0x040053AD RID: 21421
			private static readonly IntPtr NativeFieldInfoPtr_lastPosition;

			// Token: 0x040053AE RID: 21422
			private static readonly IntPtr NativeFieldInfoPtr_toHitNormal;

			// Token: 0x040053AF RID: 21423
			private static readonly IntPtr NativeFieldInfoPtr_r;

			// Token: 0x040053B0 RID: 21424
			private static readonly IntPtr NativeFieldInfoPtr_heelHit;

			// Token: 0x040053B1 RID: 21425
			private static readonly IntPtr NativeFieldInfoPtr_up;

			// Token: 0x040053B2 RID: 21426
			private static readonly IntPtr NativeMethodInfoPtr_get_isGrounded_Public_get_Boolean_0;

			// Token: 0x040053B3 RID: 21427
			private static readonly IntPtr NativeMethodInfoPtr_set_isGrounded_Private_set_Void_Boolean_0;

			// Token: 0x040053B4 RID: 21428
			private static readonly IntPtr NativeMethodInfoPtr_get_IKPosition_Public_get_Vector3_0;

			// Token: 0x040053B5 RID: 21429
			private static readonly IntPtr NativeMethodInfoPtr_set_IKPosition_Private_set_Void_Vector3_0;

			// Token: 0x040053B6 RID: 21430
			private static readonly IntPtr NativeMethodInfoPtr_get_initiated_Public_get_Boolean_0;

			// Token: 0x040053B7 RID: 21431
			private static readonly IntPtr NativeMethodInfoPtr_set_initiated_Private_set_Void_Boolean_0;

			// Token: 0x040053B8 RID: 21432
			private static readonly IntPtr NativeMethodInfoPtr_get_heightFromGround_Public_get_Single_0;

			// Token: 0x040053B9 RID: 21433
			private static readonly IntPtr NativeMethodInfoPtr_set_heightFromGround_Private_set_Void_Single_0;

			// Token: 0x040053BA RID: 21434
			private static readonly IntPtr NativeMethodInfoPtr_get_velocity_Public_get_Vector3_0;

			// Token: 0x040053BB RID: 21435
			private static readonly IntPtr NativeMethodInfoPtr_set_velocity_Private_set_Void_Vector3_0;

			// Token: 0x040053BC RID: 21436
			private static readonly IntPtr NativeMethodInfoPtr_get_transform_Public_get_Transform_0;

			// Token: 0x040053BD RID: 21437
			private static readonly IntPtr NativeMethodInfoPtr_set_transform_Private_set_Void_Transform_0;

			// Token: 0x040053BE RID: 21438
			private static readonly IntPtr NativeMethodInfoPtr_get_IKOffset_Public_get_Single_0;

			// Token: 0x040053BF RID: 21439
			private static readonly IntPtr NativeMethodInfoPtr_set_IKOffset_Private_set_Void_Single_0;

			// Token: 0x040053C0 RID: 21440
			private static readonly IntPtr NativeMethodInfoPtr_Initiate_Public_Void_Grounding_Transform_0;

			// Token: 0x040053C1 RID: 21441
			private static readonly IntPtr NativeMethodInfoPtr_OnEnable_Public_Void_0;

			// Token: 0x040053C2 RID: 21442
			private static readonly IntPtr NativeMethodInfoPtr_Reset_Public_Void_0;

			// Token: 0x040053C3 RID: 21443
			private static readonly IntPtr NativeMethodInfoPtr_Process_Public_Void_0;

			// Token: 0x040053C4 RID: 21444
			private static readonly IntPtr NativeMethodInfoPtr_get_stepHeightFromGround_Public_get_Single_0;

			// Token: 0x040053C5 RID: 21445
			private static readonly IntPtr NativeMethodInfoPtr_GetCapsuleHit_Private_RaycastHit_Vector3_0;

			// Token: 0x040053C6 RID: 21446
			private static readonly IntPtr NativeMethodInfoPtr_GetRaycastHit_Private_RaycastHit_Vector3_0;

			// Token: 0x040053C7 RID: 21447
			private static readonly IntPtr NativeMethodInfoPtr_RotateNormal_Private_Vector3_Vector3_0;

			// Token: 0x040053C8 RID: 21448
			private static readonly IntPtr NativeMethodInfoPtr_SetFootToPoint_Private_Void_Vector3_Vector3_0;

			// Token: 0x040053C9 RID: 21449
			private static readonly IntPtr NativeMethodInfoPtr_SetFootToPlane_Private_Void_Vector3_Vector3_Vector3_0;

			// Token: 0x040053CA RID: 21450
			private static readonly IntPtr NativeMethodInfoPtr_GetHeightFromGround_Private_Single_Vector3_0;

			// Token: 0x040053CB RID: 21451
			private static readonly IntPtr NativeMethodInfoPtr_RotateFoot_Private_Void_0;

			// Token: 0x040053CC RID: 21452
			private static readonly IntPtr NativeMethodInfoPtr_GetRotationOffsetTarget_Private_Quaternion_0;

			// Token: 0x040053CD RID: 21453
			private static readonly IntPtr NativeMethodInfoPtr_get_rootYOffset_Private_get_Single_0;

			// Token: 0x040053CE RID: 21454
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
		}

		// Token: 0x02000414 RID: 1044
		public class Pelvis : Il2CppSystem.Object
		{
			// Token: 0x17002AE0 RID: 10976
			// (get) Token: 0x06007D78 RID: 32120 RVA: 0x001FF3C0 File Offset: 0x001FD5C0
			// (set) Token: 0x06007D79 RID: 32121 RVA: 0x001FF410 File Offset: 0x001FD610
			public unsafe Vector3 IKOffset
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.Pelvis.NativeMethodInfoPtr_get_IKOffset_Public_get_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
				[CallerCount(0)]
				set
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					checked
					{
						IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
						*ptr = ref value;
						IntPtr intPtr2;
						IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.Pelvis.NativeMethodInfoPtr_set_IKOffset_Private_set_Void_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
						Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					}
				}
			}

			// Token: 0x17002AE1 RID: 10977
			// (get) Token: 0x06007D7A RID: 32122 RVA: 0x001FF464 File Offset: 0x001FD664
			// (set) Token: 0x06007D7B RID: 32123 RVA: 0x001FF4B4 File Offset: 0x001FD6B4
			public unsafe float heightOffset
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.Pelvis.NativeMethodInfoPtr_get_heightOffset_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
				[CallerCount(4)]
				[CachedScanResults(RefRangeStart = 216230, RefRangeEnd = 216234, XrefRangeStart = 216230, XrefRangeEnd = 216234, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
				set
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					checked
					{
						IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
						*ptr = ref value;
						IntPtr intPtr2;
						IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.Pelvis.NativeMethodInfoPtr_set_heightOffset_Private_set_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
						Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					}
				}
			}

			// Token: 0x06007D7C RID: 32124 RVA: 0x001FF508 File Offset: 0x001FD708
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 595229, RefRangeEnd = 595230, XrefRangeStart = 595225, XrefRangeEnd = 595229, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void Initiate(Grounding grounding)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				checked
				{
					IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(grounding);
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.Pelvis.NativeMethodInfoPtr_Initiate_Public_Void_Grounding_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				}
			}

			// Token: 0x06007D7D RID: 32125 RVA: 0x001FF564 File Offset: 0x001FD764
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 595234, RefRangeEnd = 595235, XrefRangeStart = 595230, XrefRangeEnd = 595234, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void Reset()
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.Pelvis.NativeMethodInfoPtr_Reset_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06007D7E RID: 32126 RVA: 0x001FF5A8 File Offset: 0x001FD7A8
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 595235, XrefRangeEnd = 595238, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void OnEnable()
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.Pelvis.NativeMethodInfoPtr_OnEnable_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06007D7F RID: 32127 RVA: 0x001FF5EC File Offset: 0x001FD7EC
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 595248, RefRangeEnd = 595249, XrefRangeStart = 595238, XrefRangeEnd = 595248, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void Process(float lowestOffset, float highestOffset, bool isGrounded)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref lowestOffset;
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref highestOffset;
				ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref isGrounded;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.Pelvis.NativeMethodInfoPtr_Process_Public_Void_Single_Single_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06007D80 RID: 32128 RVA: 0x001FF668 File Offset: 0x001FD868
			[CallerCount(1642)]
			[CachedScanResults(RefRangeStart = 7417, RefRangeEnd = 9059, XrefRangeStart = 7417, XrefRangeEnd = 9059, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe Pelvis()
				: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<Grounding.Pelvis>.NativeClassPtr))
			{
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.Pelvis.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06007D81 RID: 32129 RVA: 0x001FF6B4 File Offset: 0x001FD8B4
			// Note: this type is marked as 'beforefieldinit'.
			static Pelvis()
			{
				Il2CppClassPointerStore<Grounding.Pelvis>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<Grounding>.NativeClassPtr, "Pelvis");
				IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<Grounding.Pelvis>.NativeClassPtr);
				Grounding.Pelvis.NativeFieldInfoPtr__IKOffset_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding.Pelvis>.NativeClassPtr, "<IKOffset>k__BackingField");
				Grounding.Pelvis.NativeFieldInfoPtr__heightOffset_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding.Pelvis>.NativeClassPtr, "<heightOffset>k__BackingField");
				Grounding.Pelvis.NativeFieldInfoPtr_grounding = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding.Pelvis>.NativeClassPtr, "grounding");
				Grounding.Pelvis.NativeFieldInfoPtr_lastRootPosition = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding.Pelvis>.NativeClassPtr, "lastRootPosition");
				Grounding.Pelvis.NativeFieldInfoPtr_damperF = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding.Pelvis>.NativeClassPtr, "damperF");
				Grounding.Pelvis.NativeFieldInfoPtr_initiated = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding.Pelvis>.NativeClassPtr, "initiated");
				Grounding.Pelvis.NativeFieldInfoPtr_lastTime = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Grounding.Pelvis>.NativeClassPtr, "lastTime");
				Grounding.Pelvis.NativeMethodInfoPtr_get_IKOffset_Public_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Pelvis>.NativeClassPtr, 100672740);
				Grounding.Pelvis.NativeMethodInfoPtr_set_IKOffset_Private_set_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Pelvis>.NativeClassPtr, 100672741);
				Grounding.Pelvis.NativeMethodInfoPtr_get_heightOffset_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Pelvis>.NativeClassPtr, 100672742);
				Grounding.Pelvis.NativeMethodInfoPtr_set_heightOffset_Private_set_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Pelvis>.NativeClassPtr, 100672743);
				Grounding.Pelvis.NativeMethodInfoPtr_Initiate_Public_Void_Grounding_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Pelvis>.NativeClassPtr, 100672744);
				Grounding.Pelvis.NativeMethodInfoPtr_Reset_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Pelvis>.NativeClassPtr, 100672745);
				Grounding.Pelvis.NativeMethodInfoPtr_OnEnable_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Pelvis>.NativeClassPtr, 100672746);
				Grounding.Pelvis.NativeMethodInfoPtr_Process_Public_Void_Single_Single_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Pelvis>.NativeClassPtr, 100672747);
				Grounding.Pelvis.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Pelvis>.NativeClassPtr, 100672748);
			}

			// Token: 0x06007D82 RID: 32130 RVA: 0x0000A688 File Offset: 0x00008888
			public Pelvis(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002AD9 RID: 10969
			// (get) Token: 0x06007D83 RID: 32131 RVA: 0x001FF820 File Offset: 0x001FDA20
			// (set) Token: 0x06007D84 RID: 32132 RVA: 0x001FF848 File Offset: 0x001FDA48
			public unsafe Vector3 _IKOffset_k__BackingField
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Pelvis.NativeFieldInfoPtr__IKOffset_k__BackingField);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Pelvis.NativeFieldInfoPtr__IKOffset_k__BackingField)) = value;
				}
			}

			// Token: 0x17002ADA RID: 10970
			// (get) Token: 0x06007D85 RID: 32133 RVA: 0x001FF86C File Offset: 0x001FDA6C
			// (set) Token: 0x06007D86 RID: 32134 RVA: 0x001FF894 File Offset: 0x001FDA94
			public unsafe float _heightOffset_k__BackingField
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Pelvis.NativeFieldInfoPtr__heightOffset_k__BackingField);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Pelvis.NativeFieldInfoPtr__heightOffset_k__BackingField)) = value;
				}
			}

			// Token: 0x17002ADB RID: 10971
			// (get) Token: 0x06007D87 RID: 32135 RVA: 0x001FF8B8 File Offset: 0x001FDAB8
			// (set) Token: 0x06007D88 RID: 32136 RVA: 0x001FF8EC File Offset: 0x001FDAEC
			public unsafe Grounding grounding
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Pelvis.NativeFieldInfoPtr_grounding);
					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(Grounding.Pelvis.NativeFieldInfoPtr_grounding), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x17002ADC RID: 10972
			// (get) Token: 0x06007D89 RID: 32137 RVA: 0x001FF914 File Offset: 0x001FDB14
			// (set) Token: 0x06007D8A RID: 32138 RVA: 0x001FF93C File Offset: 0x001FDB3C
			public unsafe Vector3 lastRootPosition
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Pelvis.NativeFieldInfoPtr_lastRootPosition);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Pelvis.NativeFieldInfoPtr_lastRootPosition)) = value;
				}
			}

			// Token: 0x17002ADD RID: 10973
			// (get) Token: 0x06007D8B RID: 32139 RVA: 0x001FF960 File Offset: 0x001FDB60
			// (set) Token: 0x06007D8C RID: 32140 RVA: 0x001FF988 File Offset: 0x001FDB88
			public unsafe float damperF
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Pelvis.NativeFieldInfoPtr_damperF);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Pelvis.NativeFieldInfoPtr_damperF)) = value;
				}
			}

			// Token: 0x17002ADE RID: 10974
			// (get) Token: 0x06007D8D RID: 32141 RVA: 0x001FF9AC File Offset: 0x001FDBAC
			// (set) Token: 0x06007D8E RID: 32142 RVA: 0x001FF9D4 File Offset: 0x001FDBD4
			public unsafe bool initiated
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Pelvis.NativeFieldInfoPtr_initiated);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Pelvis.NativeFieldInfoPtr_initiated)) = value;
				}
			}

			// Token: 0x17002ADF RID: 10975
			// (get) Token: 0x06007D8F RID: 32143 RVA: 0x001FF9F8 File Offset: 0x001FDBF8
			// (set) Token: 0x06007D90 RID: 32144 RVA: 0x001FFA20 File Offset: 0x001FDC20
			public unsafe float lastTime
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Pelvis.NativeFieldInfoPtr_lastTime);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Grounding.Pelvis.NativeFieldInfoPtr_lastTime)) = value;
				}
			}

			// Token: 0x040053CF RID: 21455
			private static readonly IntPtr NativeFieldInfoPtr__IKOffset_k__BackingField;

			// Token: 0x040053D0 RID: 21456
			private static readonly IntPtr NativeFieldInfoPtr__heightOffset_k__BackingField;

			// Token: 0x040053D1 RID: 21457
			private static readonly IntPtr NativeFieldInfoPtr_grounding;

			// Token: 0x040053D2 RID: 21458
			private static readonly IntPtr NativeFieldInfoPtr_lastRootPosition;

			// Token: 0x040053D3 RID: 21459
			private static readonly IntPtr NativeFieldInfoPtr_damperF;

			// Token: 0x040053D4 RID: 21460
			private static readonly IntPtr NativeFieldInfoPtr_initiated;

			// Token: 0x040053D5 RID: 21461
			private static readonly IntPtr NativeFieldInfoPtr_lastTime;

			// Token: 0x040053D6 RID: 21462
			private static readonly IntPtr NativeMethodInfoPtr_get_IKOffset_Public_get_Vector3_0;

			// Token: 0x040053D7 RID: 21463
			private static readonly IntPtr NativeMethodInfoPtr_set_IKOffset_Private_set_Void_Vector3_0;

			// Token: 0x040053D8 RID: 21464
			private static readonly IntPtr NativeMethodInfoPtr_get_heightOffset_Public_get_Single_0;

			// Token: 0x040053D9 RID: 21465
			private static readonly IntPtr NativeMethodInfoPtr_set_heightOffset_Private_set_Void_Single_0;

			// Token: 0x040053DA RID: 21466
			private static readonly IntPtr NativeMethodInfoPtr_Initiate_Public_Void_Grounding_0;

			// Token: 0x040053DB RID: 21467
			private static readonly IntPtr NativeMethodInfoPtr_Reset_Public_Void_0;

			// Token: 0x040053DC RID: 21468
			private static readonly IntPtr NativeMethodInfoPtr_OnEnable_Public_Void_0;

			// Token: 0x040053DD RID: 21469
			private static readonly IntPtr NativeMethodInfoPtr_Process_Public_Void_Single_Single_Boolean_0;

			// Token: 0x040053DE RID: 21470
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
		}
	}
}
