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

namespace RootMotion.FinalIK
{
	// Token: 0x020004D4 RID: 1236
	public class HitReaction : OffsetModifier
	{
		// Token: 0x170030F0 RID: 12528
		// (get) Token: 0x06009068 RID: 36968 RVA: 0x00250D90 File Offset: 0x0024EF90
		public unsafe bool inProgress
		{
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 636439, XrefRangeEnd = 636443, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			get
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(HitReaction.NativeMethodInfoPtr_get_inProgress_Public_get_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}
		}

		// Token: 0x06009069 RID: 36969 RVA: 0x00250DE0 File Offset: 0x0024EFE0
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 636443, XrefRangeEnd = 636447, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe override void OnModifyOffset()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), HitReaction.NativeMethodInfoPtr_OnModifyOffset_Protected_Virtual_Void_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x0600906A RID: 36970 RVA: 0x00250E30 File Offset: 0x0024F030
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 636467, RefRangeEnd = 636468, XrefRangeStart = 636447, XrefRangeEnd = 636467, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void Hit(Collider collider, Vector3 force, Vector3 point)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(collider);
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref force;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref point;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(HitReaction.NativeMethodInfoPtr_Hit_Public_Void_Collider_Vector3_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

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

		// Token: 0x0600906C RID: 36972 RVA: 0x00250EFC File Offset: 0x0024F0FC
		// Note: this type is marked as 'beforefieldinit'.
		static HitReaction()
		{
			Il2CppClassPointerStore<HitReaction>.NativeClassPtr = IL2CPP.GetIl2CppClass("Assembly-CSharp.dll", "RootMotion.FinalIK", "HitReaction");
			IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<HitReaction>.NativeClassPtr);
			HitReaction.NativeFieldInfoPtr_effectorHitPoints = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReaction>.NativeClassPtr, "effectorHitPoints");
			HitReaction.NativeFieldInfoPtr_boneHitPoints = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReaction>.NativeClassPtr, "boneHitPoints");
			HitReaction.NativeMethodInfoPtr_get_inProgress_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction>.NativeClassPtr, 100674400);
			HitReaction.NativeMethodInfoPtr_OnModifyOffset_Protected_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction>.NativeClassPtr, 100674401);
			HitReaction.NativeMethodInfoPtr_Hit_Public_Void_Collider_Vector3_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction>.NativeClassPtr, 100674402);
			HitReaction.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction>.NativeClassPtr, 100674403);
		}

		// Token: 0x0600906D RID: 36973 RVA: 0x002089BC File Offset: 0x00206BBC
		public HitReaction(IntPtr pointer)
			: base(pointer)
		{
		}

		// Token: 0x170030EE RID: 12526
		// (get) Token: 0x0600906E RID: 36974 RVA: 0x00250FA4 File Offset: 0x0024F1A4
		// (set) Token: 0x0600906F RID: 36975 RVA: 0x00250FD8 File Offset: 0x0024F1D8
		public unsafe Il2CppReferenceArray<HitReaction.HitPointEffector> effectorHitPoints
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.NativeFieldInfoPtr_effectorHitPoints);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new Il2CppReferenceArray<HitReaction.HitPointEffector>(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.NativeFieldInfoPtr_effectorHitPoints), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x170030EF RID: 12527
		// (get) Token: 0x06009070 RID: 36976 RVA: 0x00251000 File Offset: 0x0024F200
		// (set) Token: 0x06009071 RID: 36977 RVA: 0x00251034 File Offset: 0x0024F234
		public unsafe Il2CppReferenceArray<HitReaction.HitPointBone> boneHitPoints
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.NativeFieldInfoPtr_boneHitPoints);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new Il2CppReferenceArray<HitReaction.HitPointBone>(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.NativeFieldInfoPtr_boneHitPoints), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x0400607B RID: 24699
		private static readonly IntPtr NativeFieldInfoPtr_effectorHitPoints;

		// Token: 0x0400607C RID: 24700
		private static readonly IntPtr NativeFieldInfoPtr_boneHitPoints;

		// Token: 0x0400607D RID: 24701
		private static readonly IntPtr NativeMethodInfoPtr_get_inProgress_Public_get_Boolean_0;

		// Token: 0x0400607E RID: 24702
		private static readonly IntPtr NativeMethodInfoPtr_OnModifyOffset_Protected_Virtual_Void_0;

		// Token: 0x0400607F RID: 24703
		private static readonly IntPtr NativeMethodInfoPtr_Hit_Public_Void_Collider_Vector3_Vector3_0;

		// Token: 0x04006080 RID: 24704
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

		// Token: 0x020004D5 RID: 1237
		[Serializable]
		public class HitPoint : Il2CppSystem.Object
		{
			// Token: 0x170030FB RID: 12539
			// (get) Token: 0x06009072 RID: 36978 RVA: 0x0025105C File Offset: 0x0024F25C
			public unsafe bool inProgress
			{
				[CallerCount(2)]
				[CachedScanResults(RefRangeStart = 636357, RefRangeEnd = 636359, XrefRangeStart = 636357, XrefRangeEnd = 636357, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(HitReaction.HitPoint.NativeMethodInfoPtr_get_inProgress_Public_get_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
			}

			// Token: 0x170030FC RID: 12540
			// (get) Token: 0x06009073 RID: 36979 RVA: 0x002510AC File Offset: 0x0024F2AC
			// (set) Token: 0x06009074 RID: 36980 RVA: 0x002510FC File Offset: 0x0024F2FC
			public unsafe float crossFader
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(HitReaction.HitPoint.NativeMethodInfoPtr_get_crossFader_Protected_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
				[CallerCount(1)]
				[CachedScanResults(RefRangeStart = 225924, RefRangeEnd = 225925, XrefRangeStart = 225924, XrefRangeEnd = 225925, 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(HitReaction.HitPoint.NativeMethodInfoPtr_set_crossFader_Private_set_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
						Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					}
				}
			}

			// Token: 0x170030FD RID: 12541
			// (get) Token: 0x06009075 RID: 36981 RVA: 0x00251150 File Offset: 0x0024F350
			// (set) Token: 0x06009076 RID: 36982 RVA: 0x002511A0 File Offset: 0x0024F3A0
			public unsafe float timer
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(HitReaction.HitPoint.NativeMethodInfoPtr_get_timer_Protected_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
				[CallerCount(2)]
				[CachedScanResults(RefRangeStart = 225930, RefRangeEnd = 225932, XrefRangeStart = 225930, XrefRangeEnd = 225932, 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(HitReaction.HitPoint.NativeMethodInfoPtr_set_timer_Private_set_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
						Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					}
				}
			}

			// Token: 0x170030FE RID: 12542
			// (get) Token: 0x06009077 RID: 36983 RVA: 0x002511F4 File Offset: 0x0024F3F4
			// (set) Token: 0x06009078 RID: 36984 RVA: 0x00251244 File Offset: 0x0024F444
			public unsafe Vector3 force
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(HitReaction.HitPoint.NativeMethodInfoPtr_get_force_Protected_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(HitReaction.HitPoint.NativeMethodInfoPtr_set_force_Private_set_Void_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
						Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					}
				}
			}

			// Token: 0x170030FF RID: 12543
			// (get) Token: 0x06009079 RID: 36985 RVA: 0x00251298 File Offset: 0x0024F498
			// (set) Token: 0x0600907A RID: 36986 RVA: 0x002512E8 File Offset: 0x0024F4E8
			public unsafe Vector3 point
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(HitReaction.HitPoint.NativeMethodInfoPtr_get_point_Protected_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(HitReaction.HitPoint.NativeMethodInfoPtr_set_point_Private_set_Void_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
						Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					}
				}
			}

			// Token: 0x0600907B RID: 36987 RVA: 0x0025133C File Offset: 0x0024F53C
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 636367, RefRangeEnd = 636369, XrefRangeStart = 636359, XrefRangeEnd = 636367, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void Hit(Vector3 force, Vector3 point)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref force;
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref point;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(HitReaction.HitPoint.NativeMethodInfoPtr_Hit_Public_Void_Vector3_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x0600907C RID: 36988 RVA: 0x002513A4 File Offset: 0x0024F5A4
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 636374, RefRangeEnd = 636376, XrefRangeStart = 636369, XrefRangeEnd = 636374, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void Apply(IKSolverFullBodyBiped solver, float weight)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(solver);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref weight;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(HitReaction.HitPoint.NativeMethodInfoPtr_Apply_Public_Void_IKSolverFullBodyBiped_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x0600907D RID: 36989 RVA: 0x00251410 File Offset: 0x0024F610
			[CallerCount(0)]
			public unsafe virtual float GetLength()
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), HitReaction.HitPoint.NativeMethodInfoPtr_GetLength_Protected_Abstract_Virtual_New_Single_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}

			// Token: 0x0600907E RID: 36990 RVA: 0x0025146C File Offset: 0x0024F66C
			[CallerCount(0)]
			public unsafe virtual void CrossFadeStart()
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), HitReaction.HitPoint.NativeMethodInfoPtr_CrossFadeStart_Protected_Abstract_Virtual_New_Void_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x0600907F RID: 36991 RVA: 0x002514BC File Offset: 0x0024F6BC
			[CallerCount(0)]
			public unsafe virtual void OnApply(IKSolverFullBodyBiped solver, float weight)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(solver);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref weight;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), HitReaction.HitPoint.NativeMethodInfoPtr_OnApply_Protected_Abstract_Virtual_New_Void_IKSolverFullBodyBiped_Single_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06009080 RID: 36992 RVA: 0x00251534 File Offset: 0x0024F734
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 636376, XrefRangeEnd = 636377, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe HitPoint()
				: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr))
			{
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(HitReaction.HitPoint.NativeMethodInfoPtr__ctor_Protected_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06009081 RID: 36993 RVA: 0x00251580 File Offset: 0x0024F780
			// Note: this type is marked as 'beforefieldinit'.
			static HitPoint()
			{
				Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<HitReaction>.NativeClassPtr, "HitPoint");
				IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr);
				HitReaction.HitPoint.NativeFieldInfoPtr_name = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, "name");
				HitReaction.HitPoint.NativeFieldInfoPtr_collider = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, "collider");
				HitReaction.HitPoint.NativeFieldInfoPtr_crossFadeTime = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, "crossFadeTime");
				HitReaction.HitPoint.NativeFieldInfoPtr__crossFader_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, "<crossFader>k__BackingField");
				HitReaction.HitPoint.NativeFieldInfoPtr__timer_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, "<timer>k__BackingField");
				HitReaction.HitPoint.NativeFieldInfoPtr__force_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, "<force>k__BackingField");
				HitReaction.HitPoint.NativeFieldInfoPtr__point_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, "<point>k__BackingField");
				HitReaction.HitPoint.NativeFieldInfoPtr_length = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, "length");
				HitReaction.HitPoint.NativeFieldInfoPtr_crossFadeSpeed = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, "crossFadeSpeed");
				HitReaction.HitPoint.NativeFieldInfoPtr_lastTime = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, "lastTime");
				HitReaction.HitPoint.NativeMethodInfoPtr_get_inProgress_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100674404);
				HitReaction.HitPoint.NativeMethodInfoPtr_get_crossFader_Protected_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100674405);
				HitReaction.HitPoint.NativeMethodInfoPtr_set_crossFader_Private_set_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100674406);
				HitReaction.HitPoint.NativeMethodInfoPtr_get_timer_Protected_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100674407);
				HitReaction.HitPoint.NativeMethodInfoPtr_set_timer_Private_set_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100674408);
				HitReaction.HitPoint.NativeMethodInfoPtr_get_force_Protected_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100674409);
				HitReaction.HitPoint.NativeMethodInfoPtr_set_force_Private_set_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100674410);
				HitReaction.HitPoint.NativeMethodInfoPtr_get_point_Protected_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100674411);
				HitReaction.HitPoint.NativeMethodInfoPtr_set_point_Private_set_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100674412);
				HitReaction.HitPoint.NativeMethodInfoPtr_Hit_Public_Void_Vector3_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100674413);
				HitReaction.HitPoint.NativeMethodInfoPtr_Apply_Public_Void_IKSolverFullBodyBiped_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100674414);
				HitReaction.HitPoint.NativeMethodInfoPtr_GetLength_Protected_Abstract_Virtual_New_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100674415);
				HitReaction.HitPoint.NativeMethodInfoPtr_CrossFadeStart_Protected_Abstract_Virtual_New_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100674416);
				HitReaction.HitPoint.NativeMethodInfoPtr_OnApply_Protected_Abstract_Virtual_New_Void_IKSolverFullBodyBiped_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100674417);
				HitReaction.HitPoint.NativeMethodInfoPtr__ctor_Protected_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100674418);
			}

			// Token: 0x06009082 RID: 36994 RVA: 0x0000A74C File Offset: 0x0000894C
			public HitPoint(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x170030F1 RID: 12529
			// (get) Token: 0x06009083 RID: 36995 RVA: 0x002517A0 File Offset: 0x0024F9A0
			// (set) Token: 0x06009084 RID: 36996 RVA: 0x002517C9 File Offset: 0x0024F9C9
			public unsafe string name
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPoint.NativeFieldInfoPtr_name);
					return IL2CPP.Il2CppStringToManaged(*intPtr);
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPoint.NativeFieldInfoPtr_name), IL2CPP.ManagedStringToIl2Cpp(value));
				}
			}

			// Token: 0x170030F2 RID: 12530
			// (get) Token: 0x06009085 RID: 36997 RVA: 0x002517F0 File Offset: 0x0024F9F0
			// (set) Token: 0x06009086 RID: 36998 RVA: 0x00251824 File Offset: 0x0024FA24
			public unsafe Collider collider
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPoint.NativeFieldInfoPtr_collider);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new Collider(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPoint.NativeFieldInfoPtr_collider), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x170030F3 RID: 12531
			// (get) Token: 0x06009087 RID: 36999 RVA: 0x0025184C File Offset: 0x0024FA4C
			// (set) Token: 0x06009088 RID: 37000 RVA: 0x00251874 File Offset: 0x0024FA74
			public unsafe float crossFadeTime
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPoint.NativeFieldInfoPtr_crossFadeTime);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPoint.NativeFieldInfoPtr_crossFadeTime)) = value;
				}
			}

			// Token: 0x170030F4 RID: 12532
			// (get) Token: 0x06009089 RID: 37001 RVA: 0x00251898 File Offset: 0x0024FA98
			// (set) Token: 0x0600908A RID: 37002 RVA: 0x002518C0 File Offset: 0x0024FAC0
			public unsafe float _crossFader_k__BackingField
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPoint.NativeFieldInfoPtr__crossFader_k__BackingField);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPoint.NativeFieldInfoPtr__crossFader_k__BackingField)) = value;
				}
			}

			// Token: 0x170030F5 RID: 12533
			// (get) Token: 0x0600908B RID: 37003 RVA: 0x002518E4 File Offset: 0x0024FAE4
			// (set) Token: 0x0600908C RID: 37004 RVA: 0x0025190C File Offset: 0x0024FB0C
			public unsafe float _timer_k__BackingField
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPoint.NativeFieldInfoPtr__timer_k__BackingField);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPoint.NativeFieldInfoPtr__timer_k__BackingField)) = value;
				}
			}

			// Token: 0x170030F6 RID: 12534
			// (get) Token: 0x0600908D RID: 37005 RVA: 0x00251930 File Offset: 0x0024FB30
			// (set) Token: 0x0600908E RID: 37006 RVA: 0x00251958 File Offset: 0x0024FB58
			public unsafe Vector3 _force_k__BackingField
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPoint.NativeFieldInfoPtr__force_k__BackingField);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPoint.NativeFieldInfoPtr__force_k__BackingField)) = value;
				}
			}

			// Token: 0x170030F7 RID: 12535
			// (get) Token: 0x0600908F RID: 37007 RVA: 0x0025197C File Offset: 0x0024FB7C
			// (set) Token: 0x06009090 RID: 37008 RVA: 0x002519A4 File Offset: 0x0024FBA4
			public unsafe Vector3 _point_k__BackingField
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPoint.NativeFieldInfoPtr__point_k__BackingField);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPoint.NativeFieldInfoPtr__point_k__BackingField)) = value;
				}
			}

			// Token: 0x170030F8 RID: 12536
			// (get) Token: 0x06009091 RID: 37009 RVA: 0x002519C8 File Offset: 0x0024FBC8
			// (set) Token: 0x06009092 RID: 37010 RVA: 0x002519F0 File Offset: 0x0024FBF0
			public unsafe float length
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPoint.NativeFieldInfoPtr_length);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPoint.NativeFieldInfoPtr_length)) = value;
				}
			}

			// Token: 0x170030F9 RID: 12537
			// (get) Token: 0x06009093 RID: 37011 RVA: 0x00251A14 File Offset: 0x0024FC14
			// (set) Token: 0x06009094 RID: 37012 RVA: 0x00251A3C File Offset: 0x0024FC3C
			public unsafe float crossFadeSpeed
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPoint.NativeFieldInfoPtr_crossFadeSpeed);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPoint.NativeFieldInfoPtr_crossFadeSpeed)) = value;
				}
			}

			// Token: 0x170030FA RID: 12538
			// (get) Token: 0x06009095 RID: 37013 RVA: 0x00251A60 File Offset: 0x0024FC60
			// (set) Token: 0x06009096 RID: 37014 RVA: 0x00251A88 File Offset: 0x0024FC88
			public unsafe float lastTime
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPoint.NativeFieldInfoPtr_lastTime);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPoint.NativeFieldInfoPtr_lastTime)) = value;
				}
			}

			// Token: 0x04006081 RID: 24705
			private static readonly IntPtr NativeFieldInfoPtr_name;

			// Token: 0x04006082 RID: 24706
			private static readonly IntPtr NativeFieldInfoPtr_collider;

			// Token: 0x04006083 RID: 24707
			private static readonly IntPtr NativeFieldInfoPtr_crossFadeTime;

			// Token: 0x04006084 RID: 24708
			private static readonly IntPtr NativeFieldInfoPtr__crossFader_k__BackingField;

			// Token: 0x04006085 RID: 24709
			private static readonly IntPtr NativeFieldInfoPtr__timer_k__BackingField;

			// Token: 0x04006086 RID: 24710
			private static readonly IntPtr NativeFieldInfoPtr__force_k__BackingField;

			// Token: 0x04006087 RID: 24711
			private static readonly IntPtr NativeFieldInfoPtr__point_k__BackingField;

			// Token: 0x04006088 RID: 24712
			private static readonly IntPtr NativeFieldInfoPtr_length;

			// Token: 0x04006089 RID: 24713
			private static readonly IntPtr NativeFieldInfoPtr_crossFadeSpeed;

			// Token: 0x0400608A RID: 24714
			private static readonly IntPtr NativeFieldInfoPtr_lastTime;

			// Token: 0x0400608B RID: 24715
			private static readonly IntPtr NativeMethodInfoPtr_get_inProgress_Public_get_Boolean_0;

			// Token: 0x0400608C RID: 24716
			private static readonly IntPtr NativeMethodInfoPtr_get_crossFader_Protected_get_Single_0;

			// Token: 0x0400608D RID: 24717
			private static readonly IntPtr NativeMethodInfoPtr_set_crossFader_Private_set_Void_Single_0;

			// Token: 0x0400608E RID: 24718
			private static readonly IntPtr NativeMethodInfoPtr_get_timer_Protected_get_Single_0;

			// Token: 0x0400608F RID: 24719
			private static readonly IntPtr NativeMethodInfoPtr_set_timer_Private_set_Void_Single_0;

			// Token: 0x04006090 RID: 24720
			private static readonly IntPtr NativeMethodInfoPtr_get_force_Protected_get_Vector3_0;

			// Token: 0x04006091 RID: 24721
			private static readonly IntPtr NativeMethodInfoPtr_set_force_Private_set_Void_Vector3_0;

			// Token: 0x04006092 RID: 24722
			private static readonly IntPtr NativeMethodInfoPtr_get_point_Protected_get_Vector3_0;

			// Token: 0x04006093 RID: 24723
			private static readonly IntPtr NativeMethodInfoPtr_set_point_Private_set_Void_Vector3_0;

			// Token: 0x04006094 RID: 24724
			private static readonly IntPtr NativeMethodInfoPtr_Hit_Public_Void_Vector3_Vector3_0;

			// Token: 0x04006095 RID: 24725
			private static readonly IntPtr NativeMethodInfoPtr_Apply_Public_Void_IKSolverFullBodyBiped_Single_0;

			// Token: 0x04006096 RID: 24726
			private static readonly IntPtr NativeMethodInfoPtr_GetLength_Protected_Abstract_Virtual_New_Single_0;

			// Token: 0x04006097 RID: 24727
			private static readonly IntPtr NativeMethodInfoPtr_CrossFadeStart_Protected_Abstract_Virtual_New_Void_0;

			// Token: 0x04006098 RID: 24728
			private static readonly IntPtr NativeMethodInfoPtr_OnApply_Protected_Abstract_Virtual_New_Void_IKSolverFullBodyBiped_Single_0;

			// Token: 0x04006099 RID: 24729
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Protected_Void_0;
		}

		// Token: 0x020004D6 RID: 1238
		[Serializable]
		public class HitPointEffector : HitReaction.HitPoint
		{
			// Token: 0x06009097 RID: 37015 RVA: 0x00251AAC File Offset: 0x0024FCAC
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 636382, XrefRangeEnd = 636397, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe override float GetLength()
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), HitReaction.HitPointEffector.NativeMethodInfoPtr_GetLength_Protected_Virtual_Single_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}

			// Token: 0x06009098 RID: 37016 RVA: 0x00251B08 File Offset: 0x0024FD08
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 636397, XrefRangeEnd = 636399, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe override void CrossFadeStart()
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), HitReaction.HitPointEffector.NativeMethodInfoPtr_CrossFadeStart_Protected_Virtual_Void_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06009099 RID: 37017 RVA: 0x00251B58 File Offset: 0x0024FD58
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 636399, XrefRangeEnd = 636405, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe override void OnApply(IKSolverFullBodyBiped solver, float weight)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(solver);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref weight;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), HitReaction.HitPointEffector.NativeMethodInfoPtr_OnApply_Protected_Virtual_Void_IKSolverFullBodyBiped_Single_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x0600909A RID: 37018 RVA: 0x00251BD0 File Offset: 0x0024FDD0
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 0, XrefRangeEnd = 0, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe HitPointEffector()
				: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<HitReaction.HitPointEffector>.NativeClassPtr))
			{
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(HitReaction.HitPointEffector.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x0600909B RID: 37019 RVA: 0x00251C1C File Offset: 0x0024FE1C
			// Note: this type is marked as 'beforefieldinit'.
			static HitPointEffector()
			{
				Il2CppClassPointerStore<HitReaction.HitPointEffector>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<HitReaction>.NativeClassPtr, "HitPointEffector");
				IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<HitReaction.HitPointEffector>.NativeClassPtr);
				HitReaction.HitPointEffector.NativeFieldInfoPtr_offsetInForceDirection = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReaction.HitPointEffector>.NativeClassPtr, "offsetInForceDirection");
				HitReaction.HitPointEffector.NativeFieldInfoPtr_offsetInUpDirection = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReaction.HitPointEffector>.NativeClassPtr, "offsetInUpDirection");
				HitReaction.HitPointEffector.NativeFieldInfoPtr_effectorLinks = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReaction.HitPointEffector>.NativeClassPtr, "effectorLinks");
				HitReaction.HitPointEffector.NativeMethodInfoPtr_GetLength_Protected_Virtual_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPointEffector>.NativeClassPtr, 100674419);
				HitReaction.HitPointEffector.NativeMethodInfoPtr_CrossFadeStart_Protected_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPointEffector>.NativeClassPtr, 100674420);
				HitReaction.HitPointEffector.NativeMethodInfoPtr_OnApply_Protected_Virtual_Void_IKSolverFullBodyBiped_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPointEffector>.NativeClassPtr, 100674421);
				HitReaction.HitPointEffector.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPointEffector>.NativeClassPtr, 100674422);
			}

			// Token: 0x0600909C RID: 37020 RVA: 0x00251CD3 File Offset: 0x0024FED3
			public HitPointEffector(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17003100 RID: 12544
			// (get) Token: 0x0600909D RID: 37021 RVA: 0x00251CDC File Offset: 0x0024FEDC
			// (set) Token: 0x0600909E RID: 37022 RVA: 0x00251D10 File Offset: 0x0024FF10
			public unsafe AnimationCurve offsetInForceDirection
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPointEffector.NativeFieldInfoPtr_offsetInForceDirection);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new AnimationCurve(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPointEffector.NativeFieldInfoPtr_offsetInForceDirection), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x17003101 RID: 12545
			// (get) Token: 0x0600909F RID: 37023 RVA: 0x00251D38 File Offset: 0x0024FF38
			// (set) Token: 0x060090A0 RID: 37024 RVA: 0x00251D6C File Offset: 0x0024FF6C
			public unsafe AnimationCurve offsetInUpDirection
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPointEffector.NativeFieldInfoPtr_offsetInUpDirection);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new AnimationCurve(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPointEffector.NativeFieldInfoPtr_offsetInUpDirection), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x17003102 RID: 12546
			// (get) Token: 0x060090A1 RID: 37025 RVA: 0x00251D94 File Offset: 0x0024FF94
			// (set) Token: 0x060090A2 RID: 37026 RVA: 0x00251DC8 File Offset: 0x0024FFC8
			public unsafe Il2CppReferenceArray<HitReaction.HitPointEffector.EffectorLink> effectorLinks
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPointEffector.NativeFieldInfoPtr_effectorLinks);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new Il2CppReferenceArray<HitReaction.HitPointEffector.EffectorLink>(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPointEffector.NativeFieldInfoPtr_effectorLinks), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x0400609A RID: 24730
			private static readonly IntPtr NativeFieldInfoPtr_offsetInForceDirection;

			// Token: 0x0400609B RID: 24731
			private static readonly IntPtr NativeFieldInfoPtr_offsetInUpDirection;

			// Token: 0x0400609C RID: 24732
			private static readonly IntPtr NativeFieldInfoPtr_effectorLinks;

			// Token: 0x0400609D RID: 24733
			private static readonly IntPtr NativeMethodInfoPtr_GetLength_Protected_Virtual_Single_0;

			// Token: 0x0400609E RID: 24734
			private static readonly IntPtr NativeMethodInfoPtr_CrossFadeStart_Protected_Virtual_Void_0;

			// Token: 0x0400609F RID: 24735
			private static readonly IntPtr NativeMethodInfoPtr_OnApply_Protected_Virtual_Void_IKSolverFullBodyBiped_Single_0;

			// Token: 0x040060A0 RID: 24736
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

			// Token: 0x020004D7 RID: 1239
			[Serializable]
			public class EffectorLink : Il2CppSystem.Object
			{
				// Token: 0x060090A3 RID: 37027 RVA: 0x00251DF0 File Offset: 0x0024FFF0
				[CallerCount(1)]
				[CachedScanResults(RefRangeStart = 636379, RefRangeEnd = 636380, XrefRangeStart = 636377, XrefRangeEnd = 636379, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
				public unsafe void Apply(IKSolverFullBodyBiped solver, Vector3 offset, float crossFader)
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr;
					checked
					{
						ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
						*ptr = IL2CPP.Il2CppObjectBaseToPtr(solver);
					}
					ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref offset;
					ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref crossFader;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(HitReaction.HitPointEffector.EffectorLink.NativeMethodInfoPtr_Apply_Public_Void_IKSolverFullBodyBiped_Vector3_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				}

				// Token: 0x060090A4 RID: 37028 RVA: 0x00251E70 File Offset: 0x00250070
				[CallerCount(2)]
				[CachedScanResults(RefRangeStart = 636380, RefRangeEnd = 636382, XrefRangeStart = 636380, XrefRangeEnd = 636380, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
				public unsafe void CrossFadeStart()
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(HitReaction.HitPointEffector.EffectorLink.NativeMethodInfoPtr_CrossFadeStart_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				}

				// Token: 0x060090A5 RID: 37029 RVA: 0x00251EB4 File Offset: 0x002500B4
				[CallerCount(1664)]
				[CachedScanResults(RefRangeStart = 7711, RefRangeEnd = 9375, XrefRangeStart = 7711, XrefRangeEnd = 9375, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
				public unsafe EffectorLink()
					: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<HitReaction.HitPointEffector.EffectorLink>.NativeClassPtr))
				{
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(HitReaction.HitPointEffector.EffectorLink.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				}

				// Token: 0x060090A6 RID: 37030 RVA: 0x00251F00 File Offset: 0x00250100
				// Note: this type is marked as 'beforefieldinit'.
				static EffectorLink()
				{
					Il2CppClassPointerStore<HitReaction.HitPointEffector.EffectorLink>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<HitReaction.HitPointEffector>.NativeClassPtr, "EffectorLink");
					IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<HitReaction.HitPointEffector.EffectorLink>.NativeClassPtr);
					HitReaction.HitPointEffector.EffectorLink.NativeFieldInfoPtr_effector = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReaction.HitPointEffector.EffectorLink>.NativeClassPtr, "effector");
					HitReaction.HitPointEffector.EffectorLink.NativeFieldInfoPtr_weight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReaction.HitPointEffector.EffectorLink>.NativeClassPtr, "weight");
					HitReaction.HitPointEffector.EffectorLink.NativeFieldInfoPtr_lastValue = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReaction.HitPointEffector.EffectorLink>.NativeClassPtr, "lastValue");
					HitReaction.HitPointEffector.EffectorLink.NativeFieldInfoPtr_current = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReaction.HitPointEffector.EffectorLink>.NativeClassPtr, "current");
					HitReaction.HitPointEffector.EffectorLink.NativeMethodInfoPtr_Apply_Public_Void_IKSolverFullBodyBiped_Vector3_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPointEffector.EffectorLink>.NativeClassPtr, 100674423);
					HitReaction.HitPointEffector.EffectorLink.NativeMethodInfoPtr_CrossFadeStart_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPointEffector.EffectorLink>.NativeClassPtr, 100674424);
					HitReaction.HitPointEffector.EffectorLink.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPointEffector.EffectorLink>.NativeClassPtr, 100674425);
				}

				// Token: 0x060090A7 RID: 37031 RVA: 0x0000A74C File Offset: 0x0000894C
				public EffectorLink(IntPtr pointer)
					: base(pointer)
				{
				}

				// Token: 0x17003103 RID: 12547
				// (get) Token: 0x060090A8 RID: 37032 RVA: 0x00251FB8 File Offset: 0x002501B8
				// (set) Token: 0x060090A9 RID: 37033 RVA: 0x00251FE0 File Offset: 0x002501E0
				public unsafe FullBodyBipedEffector effector
				{
					get
					{
						IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPointEffector.EffectorLink.NativeFieldInfoPtr_effector);
						return *intPtr;
					}
					set
					{
						*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPointEffector.EffectorLink.NativeFieldInfoPtr_effector)) = value;
					}
				}

				// Token: 0x17003104 RID: 12548
				// (get) Token: 0x060090AA RID: 37034 RVA: 0x00252004 File Offset: 0x00250204
				// (set) Token: 0x060090AB RID: 37035 RVA: 0x0025202C File Offset: 0x0025022C
				public unsafe float weight
				{
					get
					{
						IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPointEffector.EffectorLink.NativeFieldInfoPtr_weight);
						return *intPtr;
					}
					set
					{
						*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPointEffector.EffectorLink.NativeFieldInfoPtr_weight)) = value;
					}
				}

				// Token: 0x17003105 RID: 12549
				// (get) Token: 0x060090AC RID: 37036 RVA: 0x00252050 File Offset: 0x00250250
				// (set) Token: 0x060090AD RID: 37037 RVA: 0x00252078 File Offset: 0x00250278
				public unsafe Vector3 lastValue
				{
					get
					{
						IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPointEffector.EffectorLink.NativeFieldInfoPtr_lastValue);
						return *intPtr;
					}
					set
					{
						*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPointEffector.EffectorLink.NativeFieldInfoPtr_lastValue)) = value;
					}
				}

				// Token: 0x17003106 RID: 12550
				// (get) Token: 0x060090AE RID: 37038 RVA: 0x0025209C File Offset: 0x0025029C
				// (set) Token: 0x060090AF RID: 37039 RVA: 0x002520C4 File Offset: 0x002502C4
				public unsafe Vector3 current
				{
					get
					{
						IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPointEffector.EffectorLink.NativeFieldInfoPtr_current);
						return *intPtr;
					}
					set
					{
						*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPointEffector.EffectorLink.NativeFieldInfoPtr_current)) = value;
					}
				}

				// Token: 0x040060A1 RID: 24737
				private static readonly IntPtr NativeFieldInfoPtr_effector;

				// Token: 0x040060A2 RID: 24738
				private static readonly IntPtr NativeFieldInfoPtr_weight;

				// Token: 0x040060A3 RID: 24739
				private static readonly IntPtr NativeFieldInfoPtr_lastValue;

				// Token: 0x040060A4 RID: 24740
				private static readonly IntPtr NativeFieldInfoPtr_current;

				// Token: 0x040060A5 RID: 24741
				private static readonly IntPtr NativeMethodInfoPtr_Apply_Public_Void_IKSolverFullBodyBiped_Vector3_Single_0;

				// Token: 0x040060A6 RID: 24742
				private static readonly IntPtr NativeMethodInfoPtr_CrossFadeStart_Public_Void_0;

				// Token: 0x040060A7 RID: 24743
				private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
			}
		}

		// Token: 0x020004D8 RID: 1240
		[Serializable]
		public class HitPointBone : HitReaction.HitPoint
		{
			// Token: 0x060090B0 RID: 37040 RVA: 0x002520E8 File Offset: 0x002502E8
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 636416, XrefRangeEnd = 636420, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe override float GetLength()
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), HitReaction.HitPointBone.NativeMethodInfoPtr_GetLength_Protected_Virtual_Single_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}

			// Token: 0x060090B1 RID: 37041 RVA: 0x00252144 File Offset: 0x00250344
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 636420, XrefRangeEnd = 636422, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe override void CrossFadeStart()
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), HitReaction.HitPointBone.NativeMethodInfoPtr_CrossFadeStart_Protected_Virtual_Void_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x060090B2 RID: 37042 RVA: 0x00252194 File Offset: 0x00250394
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 636422, XrefRangeEnd = 636439, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe override void OnApply(IKSolverFullBodyBiped solver, float weight)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(solver);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref weight;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), HitReaction.HitPointBone.NativeMethodInfoPtr_OnApply_Protected_Virtual_Void_IKSolverFullBodyBiped_Single_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x060090B3 RID: 37043 RVA: 0x0025220C File Offset: 0x0025040C
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 0, XrefRangeEnd = 0, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe HitPointBone()
				: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<HitReaction.HitPointBone>.NativeClassPtr))
			{
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(HitReaction.HitPointBone.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x060090B4 RID: 37044 RVA: 0x00252258 File Offset: 0x00250458
			// Note: this type is marked as 'beforefieldinit'.
			static HitPointBone()
			{
				Il2CppClassPointerStore<HitReaction.HitPointBone>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<HitReaction>.NativeClassPtr, "HitPointBone");
				IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<HitReaction.HitPointBone>.NativeClassPtr);
				HitReaction.HitPointBone.NativeFieldInfoPtr_aroundCenterOfMass = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReaction.HitPointBone>.NativeClassPtr, "aroundCenterOfMass");
				HitReaction.HitPointBone.NativeFieldInfoPtr_boneLinks = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReaction.HitPointBone>.NativeClassPtr, "boneLinks");
				HitReaction.HitPointBone.NativeFieldInfoPtr_rigidbody = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReaction.HitPointBone>.NativeClassPtr, "rigidbody");
				HitReaction.HitPointBone.NativeMethodInfoPtr_GetLength_Protected_Virtual_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPointBone>.NativeClassPtr, 100674426);
				HitReaction.HitPointBone.NativeMethodInfoPtr_CrossFadeStart_Protected_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPointBone>.NativeClassPtr, 100674427);
				HitReaction.HitPointBone.NativeMethodInfoPtr_OnApply_Protected_Virtual_Void_IKSolverFullBodyBiped_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPointBone>.NativeClassPtr, 100674428);
				HitReaction.HitPointBone.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPointBone>.NativeClassPtr, 100674429);
			}

			// Token: 0x060090B5 RID: 37045 RVA: 0x00251CD3 File Offset: 0x0024FED3
			public HitPointBone(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17003107 RID: 12551
			// (get) Token: 0x060090B6 RID: 37046 RVA: 0x00252310 File Offset: 0x00250510
			// (set) Token: 0x060090B7 RID: 37047 RVA: 0x00252344 File Offset: 0x00250544
			public unsafe AnimationCurve aroundCenterOfMass
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPointBone.NativeFieldInfoPtr_aroundCenterOfMass);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new AnimationCurve(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPointBone.NativeFieldInfoPtr_aroundCenterOfMass), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x17003108 RID: 12552
			// (get) Token: 0x060090B8 RID: 37048 RVA: 0x0025236C File Offset: 0x0025056C
			// (set) Token: 0x060090B9 RID: 37049 RVA: 0x002523A0 File Offset: 0x002505A0
			public unsafe Il2CppReferenceArray<HitReaction.HitPointBone.BoneLink> boneLinks
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPointBone.NativeFieldInfoPtr_boneLinks);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new Il2CppReferenceArray<HitReaction.HitPointBone.BoneLink>(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPointBone.NativeFieldInfoPtr_boneLinks), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x17003109 RID: 12553
			// (get) Token: 0x060090BA RID: 37050 RVA: 0x002523C8 File Offset: 0x002505C8
			// (set) Token: 0x060090BB RID: 37051 RVA: 0x002523FC File Offset: 0x002505FC
			public unsafe Rigidbody rigidbody
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPointBone.NativeFieldInfoPtr_rigidbody);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new Rigidbody(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPointBone.NativeFieldInfoPtr_rigidbody), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x040060A8 RID: 24744
			private static readonly IntPtr NativeFieldInfoPtr_aroundCenterOfMass;

			// Token: 0x040060A9 RID: 24745
			private static readonly IntPtr NativeFieldInfoPtr_boneLinks;

			// Token: 0x040060AA RID: 24746
			private static readonly IntPtr NativeFieldInfoPtr_rigidbody;

			// Token: 0x040060AB RID: 24747
			private static readonly IntPtr NativeMethodInfoPtr_GetLength_Protected_Virtual_Single_0;

			// Token: 0x040060AC RID: 24748
			private static readonly IntPtr NativeMethodInfoPtr_CrossFadeStart_Protected_Virtual_Void_0;

			// Token: 0x040060AD RID: 24749
			private static readonly IntPtr NativeMethodInfoPtr_OnApply_Protected_Virtual_Void_IKSolverFullBodyBiped_Single_0;

			// Token: 0x040060AE RID: 24750
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

			// Token: 0x020004D9 RID: 1241
			[Serializable]
			public class BoneLink : Il2CppSystem.Object
			{
				// Token: 0x060090BC RID: 37052 RVA: 0x00252424 File Offset: 0x00250624
				[CallerCount(1)]
				[CachedScanResults(RefRangeStart = 636411, RefRangeEnd = 636412, XrefRangeStart = 636405, XrefRangeEnd = 636411, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
				public unsafe void Apply(IKSolverFullBodyBiped solver, Quaternion offset, float crossFader)
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr;
					checked
					{
						ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
						*ptr = IL2CPP.Il2CppObjectBaseToPtr(solver);
					}
					ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref offset;
					ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref crossFader;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(HitReaction.HitPointBone.BoneLink.NativeMethodInfoPtr_Apply_Public_Void_IKSolverFullBodyBiped_Quaternion_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				}

				// Token: 0x060090BD RID: 37053 RVA: 0x002524A4 File Offset: 0x002506A4
				[CallerCount(1)]
				[CachedScanResults(RefRangeStart = 636412, RefRangeEnd = 636413, XrefRangeStart = 636412, XrefRangeEnd = 636412, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
				public unsafe void CrossFadeStart()
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(HitReaction.HitPointBone.BoneLink.NativeMethodInfoPtr_CrossFadeStart_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				}

				// Token: 0x060090BE RID: 37054 RVA: 0x002524E8 File Offset: 0x002506E8
				[CallerCount(0)]
				[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 636413, XrefRangeEnd = 636416, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
				public unsafe BoneLink()
					: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<HitReaction.HitPointBone.BoneLink>.NativeClassPtr))
				{
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(HitReaction.HitPointBone.BoneLink.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				}

				// Token: 0x060090BF RID: 37055 RVA: 0x00252534 File Offset: 0x00250734
				// Note: this type is marked as 'beforefieldinit'.
				static BoneLink()
				{
					Il2CppClassPointerStore<HitReaction.HitPointBone.BoneLink>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<HitReaction.HitPointBone>.NativeClassPtr, "BoneLink");
					IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<HitReaction.HitPointBone.BoneLink>.NativeClassPtr);
					HitReaction.HitPointBone.BoneLink.NativeFieldInfoPtr_bone = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReaction.HitPointBone.BoneLink>.NativeClassPtr, "bone");
					HitReaction.HitPointBone.BoneLink.NativeFieldInfoPtr_weight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReaction.HitPointBone.BoneLink>.NativeClassPtr, "weight");
					HitReaction.HitPointBone.BoneLink.NativeFieldInfoPtr_lastValue = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReaction.HitPointBone.BoneLink>.NativeClassPtr, "lastValue");
					HitReaction.HitPointBone.BoneLink.NativeFieldInfoPtr_current = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReaction.HitPointBone.BoneLink>.NativeClassPtr, "current");
					HitReaction.HitPointBone.BoneLink.NativeMethodInfoPtr_Apply_Public_Void_IKSolverFullBodyBiped_Quaternion_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPointBone.BoneLink>.NativeClassPtr, 100674430);
					HitReaction.HitPointBone.BoneLink.NativeMethodInfoPtr_CrossFadeStart_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPointBone.BoneLink>.NativeClassPtr, 100674431);
					HitReaction.HitPointBone.BoneLink.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPointBone.BoneLink>.NativeClassPtr, 100674432);
				}

				// Token: 0x060090C0 RID: 37056 RVA: 0x0000A74C File Offset: 0x0000894C
				public BoneLink(IntPtr pointer)
					: base(pointer)
				{
				}

				// Token: 0x1700310A RID: 12554
				// (get) Token: 0x060090C1 RID: 37057 RVA: 0x002525EC File Offset: 0x002507EC
				// (set) Token: 0x060090C2 RID: 37058 RVA: 0x00252620 File Offset: 0x00250820
				public unsafe Transform bone
				{
					get
					{
						IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPointBone.BoneLink.NativeFieldInfoPtr_bone);
						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(HitReaction.HitPointBone.BoneLink.NativeFieldInfoPtr_bone), IL2CPP.Il2CppObjectBaseToPtr(value));
					}
				}

				// Token: 0x1700310B RID: 12555
				// (get) Token: 0x060090C3 RID: 37059 RVA: 0x00252648 File Offset: 0x00250848
				// (set) Token: 0x060090C4 RID: 37060 RVA: 0x00252670 File Offset: 0x00250870
				public unsafe float weight
				{
					get
					{
						IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPointBone.BoneLink.NativeFieldInfoPtr_weight);
						return *intPtr;
					}
					set
					{
						*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPointBone.BoneLink.NativeFieldInfoPtr_weight)) = value;
					}
				}

				// Token: 0x1700310C RID: 12556
				// (get) Token: 0x060090C5 RID: 37061 RVA: 0x00252694 File Offset: 0x00250894
				// (set) Token: 0x060090C6 RID: 37062 RVA: 0x002526BC File Offset: 0x002508BC
				public unsafe Quaternion lastValue
				{
					get
					{
						IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPointBone.BoneLink.NativeFieldInfoPtr_lastValue);
						return *intPtr;
					}
					set
					{
						*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPointBone.BoneLink.NativeFieldInfoPtr_lastValue)) = value;
					}
				}

				// Token: 0x1700310D RID: 12557
				// (get) Token: 0x060090C7 RID: 37063 RVA: 0x002526E0 File Offset: 0x002508E0
				// (set) Token: 0x060090C8 RID: 37064 RVA: 0x00252708 File Offset: 0x00250908
				public unsafe Quaternion current
				{
					get
					{
						IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPointBone.BoneLink.NativeFieldInfoPtr_current);
						return *intPtr;
					}
					set
					{
						*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReaction.HitPointBone.BoneLink.NativeFieldInfoPtr_current)) = value;
					}
				}

				// Token: 0x040060AF RID: 24751
				private static readonly IntPtr NativeFieldInfoPtr_bone;

				// Token: 0x040060B0 RID: 24752
				private static readonly IntPtr NativeFieldInfoPtr_weight;

				// Token: 0x040060B1 RID: 24753
				private static readonly IntPtr NativeFieldInfoPtr_lastValue;

				// Token: 0x040060B2 RID: 24754
				private static readonly IntPtr NativeFieldInfoPtr_current;

				// Token: 0x040060B3 RID: 24755
				private static readonly IntPtr NativeMethodInfoPtr_Apply_Public_Void_IKSolverFullBodyBiped_Quaternion_Single_0;

				// Token: 0x040060B4 RID: 24756
				private static readonly IntPtr NativeMethodInfoPtr_CrossFadeStart_Public_Void_0;

				// Token: 0x040060B5 RID: 24757
				private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
			}
		}
	}
}
