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

namespace RootMotion.FinalIK
{
	// Token: 0x02000469 RID: 1129
	[Serializable]
	public class Grounding : Il2CppSystem.Object
	{
		// Token: 0x17002D52 RID: 11602
		// (get) Token: 0x06008542 RID: 34114 RVA: 0x0021FB14 File Offset: 0x0021DD14
		// (set) Token: 0x06008543 RID: 34115 RVA: 0x0021FB6C File Offset: 0x0021DD6C
		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: 0x17002D53 RID: 11603
		// (get) Token: 0x06008544 RID: 34116 RVA: 0x0021FBC8 File Offset: 0x0021DDC8
		// (set) Token: 0x06008545 RID: 34117 RVA: 0x0021FC20 File Offset: 0x0021DE20
		public unsafe Grounding.Pelvis pelvis
		{
			[CallerCount(32)]
			[CachedScanResults(RefRangeStart = 18846, RefRangeEnd = 18878, XrefRangeStart = 18846, XrefRangeEnd = 18878, 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: 0x17002D54 RID: 11604
		// (get) Token: 0x06008546 RID: 34118 RVA: 0x0021FC7C File Offset: 0x0021DE7C
		// (set) Token: 0x06008547 RID: 34119 RVA: 0x0021FCCC File Offset: 0x0021DECC
		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: 0x17002D55 RID: 11605
		// (get) Token: 0x06008548 RID: 34120 RVA: 0x0021FD20 File Offset: 0x0021DF20
		// (set) Token: 0x06008549 RID: 34121 RVA: 0x0021FD78 File Offset: 0x0021DF78
		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: 0x17002D56 RID: 11606
		// (get) Token: 0x0600854A RID: 34122 RVA: 0x0021FDD4 File Offset: 0x0021DFD4
		// (set) Token: 0x0600854B RID: 34123 RVA: 0x0021FE24 File Offset: 0x0021E024
		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: 0x17002D57 RID: 11607
		// (get) Token: 0x0600854C RID: 34124 RVA: 0x0021FE78 File Offset: 0x0021E078
		public unsafe bool rootGrounded
		{
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 627564, RefRangeEnd = 627566, XrefRangeStart = 627563, XrefRangeEnd = 627564, 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: 0x0600854D RID: 34125 RVA: 0x0021FEC8 File Offset: 0x0021E0C8
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 627586, RefRangeEnd = 627587, XrefRangeStart = 627566, XrefRangeEnd = 627586, 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: 0x0600854E RID: 34126 RVA: 0x0021FF2C File Offset: 0x0021E12C
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 627587, XrefRangeEnd = 627595, 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: 0x0600854F RID: 34127 RVA: 0x0021FFAC File Offset: 0x0021E1AC
		[CallerCount(5)]
		[CachedScanResults(RefRangeStart = 627628, RefRangeEnd = 627633, XrefRangeStart = 627595, XrefRangeEnd = 627628, 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: 0x06008550 RID: 34128 RVA: 0x00220020 File Offset: 0x0021E220
		[CallerCount(5)]
		[CachedScanResults(RefRangeStart = 627648, RefRangeEnd = 627653, XrefRangeStart = 627633, XrefRangeEnd = 627648, 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: 0x06008551 RID: 34129 RVA: 0x00220064 File Offset: 0x0021E264
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 627662, RefRangeEnd = 627663, XrefRangeStart = 627653, XrefRangeEnd = 627662, 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: 0x06008552 RID: 34130 RVA: 0x002200B4 File Offset: 0x0021E2B4
		[CallerCount(5)]
		[CachedScanResults(RefRangeStart = 627667, RefRangeEnd = 627672, XrefRangeStart = 627663, XrefRangeEnd = 627667, 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: 0x06008553 RID: 34131 RVA: 0x002200F8 File Offset: 0x0021E2F8
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 627672, XrefRangeEnd = 627673, 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: 0x17002D58 RID: 11608
		// (get) Token: 0x06008554 RID: 34132 RVA: 0x00220154 File Offset: 0x0021E354
		public unsafe Vector3 up
		{
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 627677, RefRangeEnd = 627679, XrefRangeStart = 627673, XrefRangeEnd = 627677, 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: 0x06008555 RID: 34133 RVA: 0x002201A4 File Offset: 0x0021E3A4
		[CallerCount(5)]
		[CachedScanResults(RefRangeStart = 627680, RefRangeEnd = 627685, XrefRangeStart = 627679, XrefRangeEnd = 627680, 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: 0x06008556 RID: 34134 RVA: 0x0022021C File Offset: 0x0021E41C
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 627686, RefRangeEnd = 627687, XrefRangeStart = 627685, XrefRangeEnd = 627686, 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: 0x17002D59 RID: 11609
		// (get) Token: 0x06008557 RID: 34135 RVA: 0x00220280 File Offset: 0x0021E480
		public unsafe bool useRootRotation
		{
			[CallerCount(6)]
			[CachedScanResults(RefRangeStart = 627690, RefRangeEnd = 627696, XrefRangeStart = 627687, XrefRangeEnd = 627690, 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: 0x06008558 RID: 34136 RVA: 0x002202D0 File Offset: 0x0021E4D0
		[CallerCount(3)]
		[CachedScanResults(RefRangeStart = 627698, RefRangeEnd = 627701, XrefRangeStart = 627696, XrefRangeEnd = 627698, 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: 0x06008559 RID: 34137 RVA: 0x00220320 File Offset: 0x0021E520
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 627701, XrefRangeEnd = 627702, 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: 0x0600855A RID: 34138 RVA: 0x0022036C File Offset: 0x0021E56C
		// 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, 100673400);
			Grounding.NativeMethodInfoPtr_set_legs_Private_set_Void_Il2CppReferenceArray_1_Leg_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100673401);
			Grounding.NativeMethodInfoPtr_get_pelvis_Public_get_Pelvis_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100673402);
			Grounding.NativeMethodInfoPtr_set_pelvis_Private_set_Void_Pelvis_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100673403);
			Grounding.NativeMethodInfoPtr_get_isGrounded_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100673404);
			Grounding.NativeMethodInfoPtr_set_isGrounded_Private_set_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100673405);
			Grounding.NativeMethodInfoPtr_get_root_Public_get_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100673406);
			Grounding.NativeMethodInfoPtr_set_root_Private_set_Void_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100673407);
			Grounding.NativeMethodInfoPtr_get_rootHit_Public_get_RaycastHit_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100673408);
			Grounding.NativeMethodInfoPtr_set_rootHit_Private_set_Void_RaycastHit_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100673409);
			Grounding.NativeMethodInfoPtr_get_rootGrounded_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100673410);
			Grounding.NativeMethodInfoPtr_GetRootHit_Public_RaycastHit_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100673411);
			Grounding.NativeMethodInfoPtr_IsValid_Public_Boolean_byref_String_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100673412);
			Grounding.NativeMethodInfoPtr_Initiate_Public_Void_Transform_Il2CppReferenceArray_1_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100673413);
			Grounding.NativeMethodInfoPtr_Update_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100673414);
			Grounding.NativeMethodInfoPtr_GetLegsPlaneNormal_Public_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100673415);
			Grounding.NativeMethodInfoPtr_Reset_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100673416);
			Grounding.NativeMethodInfoPtr_LogWarning_Public_Void_String_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100673417);
			Grounding.NativeMethodInfoPtr_get_up_Public_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100673418);
			Grounding.NativeMethodInfoPtr_GetVerticalOffset_Public_Single_Vector3_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100673419);
			Grounding.NativeMethodInfoPtr_Flatten_Public_Vector3_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100673420);
			Grounding.NativeMethodInfoPtr_get_useRootRotation_Private_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100673421);
			Grounding.NativeMethodInfoPtr_GetFootCenterOffset_Public_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100673422);
			Grounding.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding>.NativeClassPtr, 100673423);
		}

		// Token: 0x0600855B RID: 34139 RVA: 0x0000A74C File Offset: 0x0000894C
		public Grounding(IntPtr pointer)
			: base(pointer)
		{
		}

		// Token: 0x17002D3B RID: 11579
		// (get) Token: 0x0600855C RID: 34140 RVA: 0x00220748 File Offset: 0x0021E948
		// (set) Token: 0x0600855D RID: 34141 RVA: 0x00220770 File Offset: 0x0021E970
		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: 0x17002D3C RID: 11580
		// (get) Token: 0x0600855E RID: 34142 RVA: 0x00220794 File Offset: 0x0021E994
		// (set) Token: 0x0600855F RID: 34143 RVA: 0x002207BC File Offset: 0x0021E9BC
		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: 0x17002D3D RID: 11581
		// (get) Token: 0x06008560 RID: 34144 RVA: 0x002207E0 File Offset: 0x0021E9E0
		// (set) Token: 0x06008561 RID: 34145 RVA: 0x00220808 File Offset: 0x0021EA08
		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: 0x17002D3E RID: 11582
		// (get) Token: 0x06008562 RID: 34146 RVA: 0x0022082C File Offset: 0x0021EA2C
		// (set) Token: 0x06008563 RID: 34147 RVA: 0x00220854 File Offset: 0x0021EA54
		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: 0x17002D3F RID: 11583
		// (get) Token: 0x06008564 RID: 34148 RVA: 0x00220878 File Offset: 0x0021EA78
		// (set) Token: 0x06008565 RID: 34149 RVA: 0x002208A0 File Offset: 0x0021EAA0
		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: 0x17002D40 RID: 11584
		// (get) Token: 0x06008566 RID: 34150 RVA: 0x002208C4 File Offset: 0x0021EAC4
		// (set) Token: 0x06008567 RID: 34151 RVA: 0x002208EC File Offset: 0x0021EAEC
		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: 0x17002D41 RID: 11585
		// (get) Token: 0x06008568 RID: 34152 RVA: 0x00220910 File Offset: 0x0021EB10
		// (set) Token: 0x06008569 RID: 34153 RVA: 0x00220938 File Offset: 0x0021EB38
		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: 0x17002D42 RID: 11586
		// (get) Token: 0x0600856A RID: 34154 RVA: 0x0022095C File Offset: 0x0021EB5C
		// (set) Token: 0x0600856B RID: 34155 RVA: 0x00220984 File Offset: 0x0021EB84
		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: 0x17002D43 RID: 11587
		// (get) Token: 0x0600856C RID: 34156 RVA: 0x002209A8 File Offset: 0x0021EBA8
		// (set) Token: 0x0600856D RID: 34157 RVA: 0x002209D0 File Offset: 0x0021EBD0
		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: 0x17002D44 RID: 11588
		// (get) Token: 0x0600856E RID: 34158 RVA: 0x002209F4 File Offset: 0x0021EBF4
		// (set) Token: 0x0600856F RID: 34159 RVA: 0x00220A1C File Offset: 0x0021EC1C
		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: 0x17002D45 RID: 11589
		// (get) Token: 0x06008570 RID: 34160 RVA: 0x00220A40 File Offset: 0x0021EC40
		// (set) Token: 0x06008571 RID: 34161 RVA: 0x00220A68 File Offset: 0x0021EC68
		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: 0x17002D46 RID: 11590
		// (get) Token: 0x06008572 RID: 34162 RVA: 0x00220A8C File Offset: 0x0021EC8C
		// (set) Token: 0x06008573 RID: 34163 RVA: 0x00220AB4 File Offset: 0x0021ECB4
		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: 0x17002D47 RID: 11591
		// (get) Token: 0x06008574 RID: 34164 RVA: 0x00220AD8 File Offset: 0x0021ECD8
		// (set) Token: 0x06008575 RID: 34165 RVA: 0x00220B00 File Offset: 0x0021ED00
		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: 0x17002D48 RID: 11592
		// (get) Token: 0x06008576 RID: 34166 RVA: 0x00220B24 File Offset: 0x0021ED24
		// (set) Token: 0x06008577 RID: 34167 RVA: 0x00220B4C File Offset: 0x0021ED4C
		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: 0x17002D49 RID: 11593
		// (get) Token: 0x06008578 RID: 34168 RVA: 0x00220B70 File Offset: 0x0021ED70
		// (set) Token: 0x06008579 RID: 34169 RVA: 0x00220B98 File Offset: 0x0021ED98
		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: 0x17002D4A RID: 11594
		// (get) Token: 0x0600857A RID: 34170 RVA: 0x00220BBC File Offset: 0x0021EDBC
		// (set) Token: 0x0600857B RID: 34171 RVA: 0x00220BE4 File Offset: 0x0021EDE4
		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: 0x17002D4B RID: 11595
		// (get) Token: 0x0600857C RID: 34172 RVA: 0x00220C08 File Offset: 0x0021EE08
		// (set) Token: 0x0600857D RID: 34173 RVA: 0x00220C30 File Offset: 0x0021EE30
		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: 0x17002D4C RID: 11596
		// (get) Token: 0x0600857E RID: 34174 RVA: 0x00220C54 File Offset: 0x0021EE54
		// (set) Token: 0x0600857F RID: 34175 RVA: 0x00220C88 File Offset: 0x0021EE88
		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: 0x17002D4D RID: 11597
		// (get) Token: 0x06008580 RID: 34176 RVA: 0x00220CB0 File Offset: 0x0021EEB0
		// (set) Token: 0x06008581 RID: 34177 RVA: 0x00220CE4 File Offset: 0x0021EEE4
		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: 0x17002D4E RID: 11598
		// (get) Token: 0x06008582 RID: 34178 RVA: 0x00220D0C File Offset: 0x0021EF0C
		// (set) Token: 0x06008583 RID: 34179 RVA: 0x00220D34 File Offset: 0x0021EF34
		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: 0x17002D4F RID: 11599
		// (get) Token: 0x06008584 RID: 34180 RVA: 0x00220D58 File Offset: 0x0021EF58
		// (set) Token: 0x06008585 RID: 34181 RVA: 0x00220D8C File Offset: 0x0021EF8C
		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: 0x17002D50 RID: 11600
		// (get) Token: 0x06008586 RID: 34182 RVA: 0x00220DB4 File Offset: 0x0021EFB4
		// (set) Token: 0x06008587 RID: 34183 RVA: 0x00220DDC File Offset: 0x0021EFDC
		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: 0x17002D51 RID: 11601
		// (get) Token: 0x06008588 RID: 34184 RVA: 0x00220E00 File Offset: 0x0021F000
		// (set) Token: 0x06008589 RID: 34185 RVA: 0x00220E28 File Offset: 0x0021F028
		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: 0x04005917 RID: 22807
		private static readonly IntPtr NativeFieldInfoPtr_layers;

		// Token: 0x04005918 RID: 22808
		private static readonly IntPtr NativeFieldInfoPtr_maxStep;

		// Token: 0x04005919 RID: 22809
		private static readonly IntPtr NativeFieldInfoPtr_heightOffset;

		// Token: 0x0400591A RID: 22810
		private static readonly IntPtr NativeFieldInfoPtr_footSpeed;

		// Token: 0x0400591B RID: 22811
		private static readonly IntPtr NativeFieldInfoPtr_footRadius;

		// Token: 0x0400591C RID: 22812
		private static readonly IntPtr NativeFieldInfoPtr_footCenterOffset;

		// Token: 0x0400591D RID: 22813
		private static readonly IntPtr NativeFieldInfoPtr_prediction;

		// Token: 0x0400591E RID: 22814
		private static readonly IntPtr NativeFieldInfoPtr_footRotationWeight;

		// Token: 0x0400591F RID: 22815
		private static readonly IntPtr NativeFieldInfoPtr_footRotationSpeed;

		// Token: 0x04005920 RID: 22816
		private static readonly IntPtr NativeFieldInfoPtr_maxFootRotationAngle;

		// Token: 0x04005921 RID: 22817
		private static readonly IntPtr NativeFieldInfoPtr_rotateSolver;

		// Token: 0x04005922 RID: 22818
		private static readonly IntPtr NativeFieldInfoPtr_pelvisSpeed;

		// Token: 0x04005923 RID: 22819
		private static readonly IntPtr NativeFieldInfoPtr_pelvisDamper;

		// Token: 0x04005924 RID: 22820
		private static readonly IntPtr NativeFieldInfoPtr_lowerPelvisWeight;

		// Token: 0x04005925 RID: 22821
		private static readonly IntPtr NativeFieldInfoPtr_liftPelvisWeight;

		// Token: 0x04005926 RID: 22822
		private static readonly IntPtr NativeFieldInfoPtr_rootSphereCastRadius;

		// Token: 0x04005927 RID: 22823
		private static readonly IntPtr NativeFieldInfoPtr_quality;

		// Token: 0x04005928 RID: 22824
		private static readonly IntPtr NativeFieldInfoPtr__legs_k__BackingField;

		// Token: 0x04005929 RID: 22825
		private static readonly IntPtr NativeFieldInfoPtr__pelvis_k__BackingField;

		// Token: 0x0400592A RID: 22826
		private static readonly IntPtr NativeFieldInfoPtr__isGrounded_k__BackingField;

		// Token: 0x0400592B RID: 22827
		private static readonly IntPtr NativeFieldInfoPtr__root_k__BackingField;

		// Token: 0x0400592C RID: 22828
		private static readonly IntPtr NativeFieldInfoPtr__rootHit_k__BackingField;

		// Token: 0x0400592D RID: 22829
		private static readonly IntPtr NativeFieldInfoPtr_initiated;

		// Token: 0x0400592E RID: 22830
		private static readonly IntPtr NativeMethodInfoPtr_get_legs_Public_get_Il2CppReferenceArray_1_Leg_0;

		// Token: 0x0400592F RID: 22831
		private static readonly IntPtr NativeMethodInfoPtr_set_legs_Private_set_Void_Il2CppReferenceArray_1_Leg_0;

		// Token: 0x04005930 RID: 22832
		private static readonly IntPtr NativeMethodInfoPtr_get_pelvis_Public_get_Pelvis_0;

		// Token: 0x04005931 RID: 22833
		private static readonly IntPtr NativeMethodInfoPtr_set_pelvis_Private_set_Void_Pelvis_0;

		// Token: 0x04005932 RID: 22834
		private static readonly IntPtr NativeMethodInfoPtr_get_isGrounded_Public_get_Boolean_0;

		// Token: 0x04005933 RID: 22835
		private static readonly IntPtr NativeMethodInfoPtr_set_isGrounded_Private_set_Void_Boolean_0;

		// Token: 0x04005934 RID: 22836
		private static readonly IntPtr NativeMethodInfoPtr_get_root_Public_get_Transform_0;

		// Token: 0x04005935 RID: 22837
		private static readonly IntPtr NativeMethodInfoPtr_set_root_Private_set_Void_Transform_0;

		// Token: 0x04005936 RID: 22838
		private static readonly IntPtr NativeMethodInfoPtr_get_rootHit_Public_get_RaycastHit_0;

		// Token: 0x04005937 RID: 22839
		private static readonly IntPtr NativeMethodInfoPtr_set_rootHit_Private_set_Void_RaycastHit_0;

		// Token: 0x04005938 RID: 22840
		private static readonly IntPtr NativeMethodInfoPtr_get_rootGrounded_Public_get_Boolean_0;

		// Token: 0x04005939 RID: 22841
		private static readonly IntPtr NativeMethodInfoPtr_GetRootHit_Public_RaycastHit_Single_0;

		// Token: 0x0400593A RID: 22842
		private static readonly IntPtr NativeMethodInfoPtr_IsValid_Public_Boolean_byref_String_0;

		// Token: 0x0400593B RID: 22843
		private static readonly IntPtr NativeMethodInfoPtr_Initiate_Public_Void_Transform_Il2CppReferenceArray_1_Transform_0;

		// Token: 0x0400593C RID: 22844
		private static readonly IntPtr NativeMethodInfoPtr_Update_Public_Void_0;

		// Token: 0x0400593D RID: 22845
		private static readonly IntPtr NativeMethodInfoPtr_GetLegsPlaneNormal_Public_Vector3_0;

		// Token: 0x0400593E RID: 22846
		private static readonly IntPtr NativeMethodInfoPtr_Reset_Public_Void_0;

		// Token: 0x0400593F RID: 22847
		private static readonly IntPtr NativeMethodInfoPtr_LogWarning_Public_Void_String_0;

		// Token: 0x04005940 RID: 22848
		private static readonly IntPtr NativeMethodInfoPtr_get_up_Public_get_Vector3_0;

		// Token: 0x04005941 RID: 22849
		private static readonly IntPtr NativeMethodInfoPtr_GetVerticalOffset_Public_Single_Vector3_Vector3_0;

		// Token: 0x04005942 RID: 22850
		private static readonly IntPtr NativeMethodInfoPtr_Flatten_Public_Vector3_Vector3_0;

		// Token: 0x04005943 RID: 22851
		private static readonly IntPtr NativeMethodInfoPtr_get_useRootRotation_Private_get_Boolean_0;

		// Token: 0x04005944 RID: 22852
		private static readonly IntPtr NativeMethodInfoPtr_GetFootCenterOffset_Public_Vector3_0;

		// Token: 0x04005945 RID: 22853
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

		// Token: 0x0200046A RID: 1130
		[Serializable]
		public enum Quality
		{
			// Token: 0x04005947 RID: 22855
			Fastest,
			// Token: 0x04005948 RID: 22856
			Simple,
			// Token: 0x04005949 RID: 22857
			Best
		}

		// Token: 0x0200046B RID: 1131
		public class Leg : Il2CppSystem.Object
		{
			// Token: 0x17002D6B RID: 11627
			// (get) Token: 0x0600858A RID: 34186 RVA: 0x00220E4C File Offset: 0x0021F04C
			// (set) Token: 0x0600858B RID: 34187 RVA: 0x00220E9C File Offset: 0x0021F09C
			public unsafe bool isGrounded
			{
				[CallerCount(1)]
				[CachedScanResults(RefRangeStart = 6864, RefRangeEnd = 6865, XrefRangeStart = 6864, XrefRangeEnd = 6865, 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: 0x17002D6C RID: 11628
			// (get) Token: 0x0600858C RID: 34188 RVA: 0x00220EF0 File Offset: 0x0021F0F0
			// (set) Token: 0x0600858D RID: 34189 RVA: 0x00220F40 File Offset: 0x0021F140
			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: 0x17002D6D RID: 11629
			// (get) Token: 0x0600858E RID: 34190 RVA: 0x00220F94 File Offset: 0x0021F194
			// (set) Token: 0x0600858F RID: 34191 RVA: 0x00220FE4 File Offset: 0x0021F1E4
			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: 0x17002D6E RID: 11630
			// (get) Token: 0x06008590 RID: 34192 RVA: 0x00221038 File Offset: 0x0021F238
			// (set) Token: 0x06008591 RID: 34193 RVA: 0x00221088 File Offset: 0x0021F288
			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 = 225954, RefRangeEnd = 225955, XrefRangeStart = 225954, XrefRangeEnd = 225955, 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: 0x17002D6F RID: 11631
			// (get) Token: 0x06008592 RID: 34194 RVA: 0x002210DC File Offset: 0x0021F2DC
			// (set) Token: 0x06008593 RID: 34195 RVA: 0x0022112C File Offset: 0x0021F32C
			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: 0x17002D70 RID: 11632
			// (get) Token: 0x06008594 RID: 34196 RVA: 0x00221180 File Offset: 0x0021F380
			// (set) Token: 0x06008595 RID: 34197 RVA: 0x002211D8 File Offset: 0x0021F3D8
			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: 0x17002D71 RID: 11633
			// (get) Token: 0x06008596 RID: 34198 RVA: 0x00221234 File Offset: 0x0021F434
			// (set) Token: 0x06008597 RID: 34199 RVA: 0x00221284 File Offset: 0x0021F484
			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 = 225983, RefRangeEnd = 225985, XrefRangeStart = 225983, XrefRangeEnd = 225985, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
				set
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					checked
					{
						IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
						*ptr = ref value;
						IntPtr intPtr2;
						IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Grounding.Leg.NativeMethodInfoPtr_set_IKOffset_Private_set_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
						Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					}
				}
			}

			// Token: 0x06008598 RID: 34200 RVA: 0x002212D8 File Offset: 0x0021F4D8
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 627410, RefRangeEnd = 627411, XrefRangeStart = 627403, XrefRangeEnd = 627410, 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: 0x06008599 RID: 34201 RVA: 0x0022134C File Offset: 0x0021F54C
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 627411, XrefRangeEnd = 627413, 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: 0x0600859A RID: 34202 RVA: 0x00221390 File Offset: 0x0021F590
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 627417, RefRangeEnd = 627418, XrefRangeStart = 627413, XrefRangeEnd = 627417, 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: 0x0600859B RID: 34203 RVA: 0x002213D4 File Offset: 0x0021F5D4
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 627475, RefRangeEnd = 627476, XrefRangeStart = 627418, XrefRangeEnd = 627475, 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: 0x17002D72 RID: 11634
			// (get) Token: 0x0600859C RID: 34204 RVA: 0x00221418 File Offset: 0x0021F618
			public unsafe float stepHeightFromGround
			{
				[CallerCount(0)]
				[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 627476, XrefRangeEnd = 627478, 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: 0x0600859D RID: 34205 RVA: 0x00221468 File Offset: 0x0021F668
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 627489, RefRangeEnd = 627490, XrefRangeStart = 627478, XrefRangeEnd = 627489, 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: 0x0600859E RID: 34206 RVA: 0x002214CC File Offset: 0x0021F6CC
			[CallerCount(5)]
			[CachedScanResults(RefRangeStart = 627495, RefRangeEnd = 627500, XrefRangeStart = 627490, XrefRangeEnd = 627495, 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: 0x0600859F RID: 34207 RVA: 0x00221530 File Offset: 0x0021F730
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 627500, XrefRangeEnd = 627501, 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: 0x060085A0 RID: 34208 RVA: 0x00221594 File Offset: 0x0021F794
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 627501, XrefRangeEnd = 627505, 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: 0x060085A1 RID: 34209 RVA: 0x002215FC File Offset: 0x0021F7FC
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 627513, RefRangeEnd = 627515, XrefRangeStart = 627505, XrefRangeEnd = 627513, 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: 0x060085A2 RID: 34210 RVA: 0x00221678 File Offset: 0x0021F878
			[CallerCount(4)]
			[CachedScanResults(RefRangeStart = 627520, RefRangeEnd = 627524, XrefRangeStart = 627515, XrefRangeEnd = 627520, 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: 0x060085A3 RID: 34211 RVA: 0x002216DC File Offset: 0x0021F8DC
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 627524, XrefRangeEnd = 627530, 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: 0x060085A4 RID: 34212 RVA: 0x00221720 File Offset: 0x0021F920
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 627530, XrefRangeEnd = 627532, 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: 0x17002D73 RID: 11635
			// (get) Token: 0x060085A5 RID: 34213 RVA: 0x00221770 File Offset: 0x0021F970
			public unsafe float rootYOffset
			{
				[CallerCount(0)]
				[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 627532, XrefRangeEnd = 627535, 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: 0x060085A6 RID: 34214 RVA: 0x002217C0 File Offset: 0x0021F9C0
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 627538, RefRangeEnd = 627539, XrefRangeStart = 627535, XrefRangeEnd = 627538, 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: 0x060085A7 RID: 34215 RVA: 0x0022180C File Offset: 0x0021FA0C
			// 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, 100673424);
				Grounding.Leg.NativeMethodInfoPtr_set_isGrounded_Private_set_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100673425);
				Grounding.Leg.NativeMethodInfoPtr_get_IKPosition_Public_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100673426);
				Grounding.Leg.NativeMethodInfoPtr_set_IKPosition_Private_set_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100673427);
				Grounding.Leg.NativeMethodInfoPtr_get_initiated_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100673428);
				Grounding.Leg.NativeMethodInfoPtr_set_initiated_Private_set_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100673429);
				Grounding.Leg.NativeMethodInfoPtr_get_heightFromGround_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100673430);
				Grounding.Leg.NativeMethodInfoPtr_set_heightFromGround_Private_set_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100673431);
				Grounding.Leg.NativeMethodInfoPtr_get_velocity_Public_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100673432);
				Grounding.Leg.NativeMethodInfoPtr_set_velocity_Private_set_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100673433);
				Grounding.Leg.NativeMethodInfoPtr_get_transform_Public_get_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100673434);
				Grounding.Leg.NativeMethodInfoPtr_set_transform_Private_set_Void_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100673435);
				Grounding.Leg.NativeMethodInfoPtr_get_IKOffset_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100673436);
				Grounding.Leg.NativeMethodInfoPtr_set_IKOffset_Private_set_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100673437);
				Grounding.Leg.NativeMethodInfoPtr_Initiate_Public_Void_Grounding_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100673438);
				Grounding.Leg.NativeMethodInfoPtr_OnEnable_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100673439);
				Grounding.Leg.NativeMethodInfoPtr_Reset_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100673440);
				Grounding.Leg.NativeMethodInfoPtr_Process_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100673441);
				Grounding.Leg.NativeMethodInfoPtr_get_stepHeightFromGround_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100673442);
				Grounding.Leg.NativeMethodInfoPtr_GetCapsuleHit_Private_RaycastHit_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100673443);
				Grounding.Leg.NativeMethodInfoPtr_GetRaycastHit_Private_RaycastHit_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100673444);
				Grounding.Leg.NativeMethodInfoPtr_RotateNormal_Private_Vector3_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100673445);
				Grounding.Leg.NativeMethodInfoPtr_SetFootToPoint_Private_Void_Vector3_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100673446);
				Grounding.Leg.NativeMethodInfoPtr_SetFootToPlane_Private_Void_Vector3_Vector3_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100673447);
				Grounding.Leg.NativeMethodInfoPtr_GetHeightFromGround_Private_Single_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100673448);
				Grounding.Leg.NativeMethodInfoPtr_RotateFoot_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100673449);
				Grounding.Leg.NativeMethodInfoPtr_GetRotationOffsetTarget_Private_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100673450);
				Grounding.Leg.NativeMethodInfoPtr_get_rootYOffset_Private_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100673451);
				Grounding.Leg.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Leg>.NativeClassPtr, 100673452);
			}

			// Token: 0x060085A8 RID: 34216 RVA: 0x0000A74C File Offset: 0x0000894C
			public Leg(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002D5A RID: 11610
			// (get) Token: 0x060085A9 RID: 34217 RVA: 0x00221BD0 File Offset: 0x0021FDD0
			// (set) Token: 0x060085AA RID: 34218 RVA: 0x00221BF8 File Offset: 0x0021FDF8
			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: 0x17002D5B RID: 11611
			// (get) Token: 0x060085AB RID: 34219 RVA: 0x00221C1C File Offset: 0x0021FE1C
			// (set) Token: 0x060085AC RID: 34220 RVA: 0x00221C44 File Offset: 0x0021FE44
			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: 0x17002D5C RID: 11612
			// (get) Token: 0x060085AD RID: 34221 RVA: 0x00221C68 File Offset: 0x0021FE68
			// (set) Token: 0x060085AE RID: 34222 RVA: 0x00221C90 File Offset: 0x0021FE90
			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: 0x17002D5D RID: 11613
			// (get) Token: 0x060085AF RID: 34223 RVA: 0x00221CB4 File Offset: 0x0021FEB4
			// (set) Token: 0x060085B0 RID: 34224 RVA: 0x00221CDC File Offset: 0x0021FEDC
			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: 0x17002D5E RID: 11614
			// (get) Token: 0x060085B1 RID: 34225 RVA: 0x00221D00 File Offset: 0x0021FF00
			// (set) Token: 0x060085B2 RID: 34226 RVA: 0x00221D28 File Offset: 0x0021FF28
			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: 0x17002D5F RID: 11615
			// (get) Token: 0x060085B3 RID: 34227 RVA: 0x00221D4C File Offset: 0x0021FF4C
			// (set) Token: 0x060085B4 RID: 34228 RVA: 0x00221D74 File Offset: 0x0021FF74
			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: 0x17002D60 RID: 11616
			// (get) Token: 0x060085B5 RID: 34229 RVA: 0x00221D98 File Offset: 0x0021FF98
			// (set) Token: 0x060085B6 RID: 34230 RVA: 0x00221DCC File Offset: 0x0021FFCC
			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: 0x17002D61 RID: 11617
			// (get) Token: 0x060085B7 RID: 34231 RVA: 0x00221DF4 File Offset: 0x0021FFF4
			// (set) Token: 0x060085B8 RID: 34232 RVA: 0x00221E1C File Offset: 0x0022001C
			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: 0x17002D62 RID: 11618
			// (get) Token: 0x060085B9 RID: 34233 RVA: 0x00221E40 File Offset: 0x00220040
			// (set) Token: 0x060085BA RID: 34234 RVA: 0x00221E68 File Offset: 0x00220068
			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: 0x17002D63 RID: 11619
			// (get) Token: 0x060085BB RID: 34235 RVA: 0x00221E8C File Offset: 0x0022008C
			// (set) Token: 0x060085BC RID: 34236 RVA: 0x00221EC0 File Offset: 0x002200C0
			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: 0x17002D64 RID: 11620
			// (get) Token: 0x060085BD RID: 34237 RVA: 0x00221EE8 File Offset: 0x002200E8
			// (set) Token: 0x060085BE RID: 34238 RVA: 0x00221F10 File Offset: 0x00220110
			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: 0x17002D65 RID: 11621
			// (get) Token: 0x060085BF RID: 34239 RVA: 0x00221F34 File Offset: 0x00220134
			// (set) Token: 0x060085C0 RID: 34240 RVA: 0x00221F5C File Offset: 0x0022015C
			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: 0x17002D66 RID: 11622
			// (get) Token: 0x060085C1 RID: 34241 RVA: 0x00221F80 File Offset: 0x00220180
			// (set) Token: 0x060085C2 RID: 34242 RVA: 0x00221FA8 File Offset: 0x002201A8
			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: 0x17002D67 RID: 11623
			// (get) Token: 0x060085C3 RID: 34243 RVA: 0x00221FCC File Offset: 0x002201CC
			// (set) Token: 0x060085C4 RID: 34244 RVA: 0x00221FF4 File Offset: 0x002201F4
			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: 0x17002D68 RID: 11624
			// (get) Token: 0x060085C5 RID: 34245 RVA: 0x00222018 File Offset: 0x00220218
			// (set) Token: 0x060085C6 RID: 34246 RVA: 0x00222040 File Offset: 0x00220240
			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: 0x17002D69 RID: 11625
			// (get) Token: 0x060085C7 RID: 34247 RVA: 0x00222064 File Offset: 0x00220264
			// (set) Token: 0x060085C8 RID: 34248 RVA: 0x0022208C File Offset: 0x0022028C
			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: 0x17002D6A RID: 11626
			// (get) Token: 0x060085C9 RID: 34249 RVA: 0x002220B0 File Offset: 0x002202B0
			// (set) Token: 0x060085CA RID: 34250 RVA: 0x002220D8 File Offset: 0x002202D8
			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: 0x0400594A RID: 22858
			private static readonly IntPtr NativeFieldInfoPtr__isGrounded_k__BackingField;

			// Token: 0x0400594B RID: 22859
			private static readonly IntPtr NativeFieldInfoPtr__IKPosition_k__BackingField;

			// Token: 0x0400594C RID: 22860
			private static readonly IntPtr NativeFieldInfoPtr_rotationOffset;

			// Token: 0x0400594D RID: 22861
			private static readonly IntPtr NativeFieldInfoPtr__initiated_k__BackingField;

			// Token: 0x0400594E RID: 22862
			private static readonly IntPtr NativeFieldInfoPtr__heightFromGround_k__BackingField;

			// Token: 0x0400594F RID: 22863
			private static readonly IntPtr NativeFieldInfoPtr__velocity_k__BackingField;

			// Token: 0x04005950 RID: 22864
			private static readonly IntPtr NativeFieldInfoPtr__transform_k__BackingField;

			// Token: 0x04005951 RID: 22865
			private static readonly IntPtr NativeFieldInfoPtr__IKOffset_k__BackingField;

			// Token: 0x04005952 RID: 22866
			private static readonly IntPtr NativeFieldInfoPtr_invertFootCenter;

			// Token: 0x04005953 RID: 22867
			private static readonly IntPtr NativeFieldInfoPtr_grounding;

			// Token: 0x04005954 RID: 22868
			private static readonly IntPtr NativeFieldInfoPtr_lastTime;

			// Token: 0x04005955 RID: 22869
			private static readonly IntPtr NativeFieldInfoPtr_deltaTime;

			// Token: 0x04005956 RID: 22870
			private static readonly IntPtr NativeFieldInfoPtr_lastPosition;

			// Token: 0x04005957 RID: 22871
			private static readonly IntPtr NativeFieldInfoPtr_toHitNormal;

			// Token: 0x04005958 RID: 22872
			private static readonly IntPtr NativeFieldInfoPtr_r;

			// Token: 0x04005959 RID: 22873
			private static readonly IntPtr NativeFieldInfoPtr_heelHit;

			// Token: 0x0400595A RID: 22874
			private static readonly IntPtr NativeFieldInfoPtr_up;

			// Token: 0x0400595B RID: 22875
			private static readonly IntPtr NativeMethodInfoPtr_get_isGrounded_Public_get_Boolean_0;

			// Token: 0x0400595C RID: 22876
			private static readonly IntPtr NativeMethodInfoPtr_set_isGrounded_Private_set_Void_Boolean_0;

			// Token: 0x0400595D RID: 22877
			private static readonly IntPtr NativeMethodInfoPtr_get_IKPosition_Public_get_Vector3_0;

			// Token: 0x0400595E RID: 22878
			private static readonly IntPtr NativeMethodInfoPtr_set_IKPosition_Private_set_Void_Vector3_0;

			// Token: 0x0400595F RID: 22879
			private static readonly IntPtr NativeMethodInfoPtr_get_initiated_Public_get_Boolean_0;

			// Token: 0x04005960 RID: 22880
			private static readonly IntPtr NativeMethodInfoPtr_set_initiated_Private_set_Void_Boolean_0;

			// Token: 0x04005961 RID: 22881
			private static readonly IntPtr NativeMethodInfoPtr_get_heightFromGround_Public_get_Single_0;

			// Token: 0x04005962 RID: 22882
			private static readonly IntPtr NativeMethodInfoPtr_set_heightFromGround_Private_set_Void_Single_0;

			// Token: 0x04005963 RID: 22883
			private static readonly IntPtr NativeMethodInfoPtr_get_velocity_Public_get_Vector3_0;

			// Token: 0x04005964 RID: 22884
			private static readonly IntPtr NativeMethodInfoPtr_set_velocity_Private_set_Void_Vector3_0;

			// Token: 0x04005965 RID: 22885
			private static readonly IntPtr NativeMethodInfoPtr_get_transform_Public_get_Transform_0;

			// Token: 0x04005966 RID: 22886
			private static readonly IntPtr NativeMethodInfoPtr_set_transform_Private_set_Void_Transform_0;

			// Token: 0x04005967 RID: 22887
			private static readonly IntPtr NativeMethodInfoPtr_get_IKOffset_Public_get_Single_0;

			// Token: 0x04005968 RID: 22888
			private static readonly IntPtr NativeMethodInfoPtr_set_IKOffset_Private_set_Void_Single_0;

			// Token: 0x04005969 RID: 22889
			private static readonly IntPtr NativeMethodInfoPtr_Initiate_Public_Void_Grounding_Transform_0;

			// Token: 0x0400596A RID: 22890
			private static readonly IntPtr NativeMethodInfoPtr_OnEnable_Public_Void_0;

			// Token: 0x0400596B RID: 22891
			private static readonly IntPtr NativeMethodInfoPtr_Reset_Public_Void_0;

			// Token: 0x0400596C RID: 22892
			private static readonly IntPtr NativeMethodInfoPtr_Process_Public_Void_0;

			// Token: 0x0400596D RID: 22893
			private static readonly IntPtr NativeMethodInfoPtr_get_stepHeightFromGround_Public_get_Single_0;

			// Token: 0x0400596E RID: 22894
			private static readonly IntPtr NativeMethodInfoPtr_GetCapsuleHit_Private_RaycastHit_Vector3_0;

			// Token: 0x0400596F RID: 22895
			private static readonly IntPtr NativeMethodInfoPtr_GetRaycastHit_Private_RaycastHit_Vector3_0;

			// Token: 0x04005970 RID: 22896
			private static readonly IntPtr NativeMethodInfoPtr_RotateNormal_Private_Vector3_Vector3_0;

			// Token: 0x04005971 RID: 22897
			private static readonly IntPtr NativeMethodInfoPtr_SetFootToPoint_Private_Void_Vector3_Vector3_0;

			// Token: 0x04005972 RID: 22898
			private static readonly IntPtr NativeMethodInfoPtr_SetFootToPlane_Private_Void_Vector3_Vector3_Vector3_0;

			// Token: 0x04005973 RID: 22899
			private static readonly IntPtr NativeMethodInfoPtr_GetHeightFromGround_Private_Single_Vector3_0;

			// Token: 0x04005974 RID: 22900
			private static readonly IntPtr NativeMethodInfoPtr_RotateFoot_Private_Void_0;

			// Token: 0x04005975 RID: 22901
			private static readonly IntPtr NativeMethodInfoPtr_GetRotationOffsetTarget_Private_Quaternion_0;

			// Token: 0x04005976 RID: 22902
			private static readonly IntPtr NativeMethodInfoPtr_get_rootYOffset_Private_get_Single_0;

			// Token: 0x04005977 RID: 22903
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
		}

		// Token: 0x0200046C RID: 1132
		public class Pelvis : Il2CppSystem.Object
		{
			// Token: 0x17002D7B RID: 11643
			// (get) Token: 0x060085CB RID: 34251 RVA: 0x002220FC File Offset: 0x002202FC
			// (set) Token: 0x060085CC RID: 34252 RVA: 0x0022214C File Offset: 0x0022034C
			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: 0x17002D7C RID: 11644
			// (get) Token: 0x060085CD RID: 34253 RVA: 0x002221A0 File Offset: 0x002203A0
			// (set) Token: 0x060085CE RID: 34254 RVA: 0x002221F0 File Offset: 0x002203F0
			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 = 223847, RefRangeEnd = 223851, XrefRangeStart = 223847, XrefRangeEnd = 223851, 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: 0x060085CF RID: 34255 RVA: 0x00222244 File Offset: 0x00220444
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 627543, RefRangeEnd = 627544, XrefRangeStart = 627539, XrefRangeEnd = 627543, 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: 0x060085D0 RID: 34256 RVA: 0x002222A0 File Offset: 0x002204A0
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 627548, RefRangeEnd = 627549, XrefRangeStart = 627544, XrefRangeEnd = 627548, 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: 0x060085D1 RID: 34257 RVA: 0x002222E4 File Offset: 0x002204E4
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 627549, XrefRangeEnd = 627552, 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: 0x060085D2 RID: 34258 RVA: 0x00222328 File Offset: 0x00220528
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 627562, RefRangeEnd = 627563, XrefRangeStart = 627552, XrefRangeEnd = 627562, 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: 0x060085D3 RID: 34259 RVA: 0x002223A4 File Offset: 0x002205A4
			[CallerCount(1664)]
			[CachedScanResults(RefRangeStart = 7711, RefRangeEnd = 9375, XrefRangeStart = 7711, XrefRangeEnd = 9375, 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: 0x060085D4 RID: 34260 RVA: 0x002223F0 File Offset: 0x002205F0
			// 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, 100673453);
				Grounding.Pelvis.NativeMethodInfoPtr_set_IKOffset_Private_set_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Pelvis>.NativeClassPtr, 100673454);
				Grounding.Pelvis.NativeMethodInfoPtr_get_heightOffset_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Pelvis>.NativeClassPtr, 100673455);
				Grounding.Pelvis.NativeMethodInfoPtr_set_heightOffset_Private_set_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Pelvis>.NativeClassPtr, 100673456);
				Grounding.Pelvis.NativeMethodInfoPtr_Initiate_Public_Void_Grounding_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Pelvis>.NativeClassPtr, 100673457);
				Grounding.Pelvis.NativeMethodInfoPtr_Reset_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Pelvis>.NativeClassPtr, 100673458);
				Grounding.Pelvis.NativeMethodInfoPtr_OnEnable_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Pelvis>.NativeClassPtr, 100673459);
				Grounding.Pelvis.NativeMethodInfoPtr_Process_Public_Void_Single_Single_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Pelvis>.NativeClassPtr, 100673460);
				Grounding.Pelvis.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Grounding.Pelvis>.NativeClassPtr, 100673461);
			}

			// Token: 0x060085D5 RID: 34261 RVA: 0x0000A74C File Offset: 0x0000894C
			public Pelvis(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002D74 RID: 11636
			// (get) Token: 0x060085D6 RID: 34262 RVA: 0x0022255C File Offset: 0x0022075C
			// (set) Token: 0x060085D7 RID: 34263 RVA: 0x00222584 File Offset: 0x00220784
			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: 0x17002D75 RID: 11637
			// (get) Token: 0x060085D8 RID: 34264 RVA: 0x002225A8 File Offset: 0x002207A8
			// (set) Token: 0x060085D9 RID: 34265 RVA: 0x002225D0 File Offset: 0x002207D0
			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: 0x17002D76 RID: 11638
			// (get) Token: 0x060085DA RID: 34266 RVA: 0x002225F4 File Offset: 0x002207F4
			// (set) Token: 0x060085DB RID: 34267 RVA: 0x00222628 File Offset: 0x00220828
			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: 0x17002D77 RID: 11639
			// (get) Token: 0x060085DC RID: 34268 RVA: 0x00222650 File Offset: 0x00220850
			// (set) Token: 0x060085DD RID: 34269 RVA: 0x00222678 File Offset: 0x00220878
			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: 0x17002D78 RID: 11640
			// (get) Token: 0x060085DE RID: 34270 RVA: 0x0022269C File Offset: 0x0022089C
			// (set) Token: 0x060085DF RID: 34271 RVA: 0x002226C4 File Offset: 0x002208C4
			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: 0x17002D79 RID: 11641
			// (get) Token: 0x060085E0 RID: 34272 RVA: 0x002226E8 File Offset: 0x002208E8
			// (set) Token: 0x060085E1 RID: 34273 RVA: 0x00222710 File Offset: 0x00220910
			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: 0x17002D7A RID: 11642
			// (get) Token: 0x060085E2 RID: 34274 RVA: 0x00222734 File Offset: 0x00220934
			// (set) Token: 0x060085E3 RID: 34275 RVA: 0x0022275C File Offset: 0x0022095C
			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: 0x04005978 RID: 22904
			private static readonly IntPtr NativeFieldInfoPtr__IKOffset_k__BackingField;

			// Token: 0x04005979 RID: 22905
			private static readonly IntPtr NativeFieldInfoPtr__heightOffset_k__BackingField;

			// Token: 0x0400597A RID: 22906
			private static readonly IntPtr NativeFieldInfoPtr_grounding;

			// Token: 0x0400597B RID: 22907
			private static readonly IntPtr NativeFieldInfoPtr_lastRootPosition;

			// Token: 0x0400597C RID: 22908
			private static readonly IntPtr NativeFieldInfoPtr_damperF;

			// Token: 0x0400597D RID: 22909
			private static readonly IntPtr NativeFieldInfoPtr_initiated;

			// Token: 0x0400597E RID: 22910
			private static readonly IntPtr NativeFieldInfoPtr_lastTime;

			// Token: 0x0400597F RID: 22911
			private static readonly IntPtr NativeMethodInfoPtr_get_IKOffset_Public_get_Vector3_0;

			// Token: 0x04005980 RID: 22912
			private static readonly IntPtr NativeMethodInfoPtr_set_IKOffset_Private_set_Void_Vector3_0;

			// Token: 0x04005981 RID: 22913
			private static readonly IntPtr NativeMethodInfoPtr_get_heightOffset_Public_get_Single_0;

			// Token: 0x04005982 RID: 22914
			private static readonly IntPtr NativeMethodInfoPtr_set_heightOffset_Private_set_Void_Single_0;

			// Token: 0x04005983 RID: 22915
			private static readonly IntPtr NativeMethodInfoPtr_Initiate_Public_Void_Grounding_0;

			// Token: 0x04005984 RID: 22916
			private static readonly IntPtr NativeMethodInfoPtr_Reset_Public_Void_0;

			// Token: 0x04005985 RID: 22917
			private static readonly IntPtr NativeMethodInfoPtr_OnEnable_Public_Void_0;

			// Token: 0x04005986 RID: 22918
			private static readonly IntPtr NativeMethodInfoPtr_Process_Public_Void_Single_Single_Boolean_0;

			// Token: 0x04005987 RID: 22919
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
		}
	}
}
