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

namespace RootMotion.FinalIK
{
	// Token: 0x0200047C RID: 1148
	public class HitReaction : OffsetModifier
	{
		// Token: 0x17002E55 RID: 11861
		// (get) Token: 0x06008815 RID: 34837 RVA: 0x0022E054 File Offset: 0x0022C254
		public unsafe bool inProgress
		{
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 604129, XrefRangeEnd = 604133, 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: 0x06008816 RID: 34838 RVA: 0x0022E0A4 File Offset: 0x0022C2A4
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 604133, XrefRangeEnd = 604137, 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: 0x06008817 RID: 34839 RVA: 0x0022E0F4 File Offset: 0x0022C2F4
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 604157, RefRangeEnd = 604158, XrefRangeStart = 604137, XrefRangeEnd = 604157, 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: 0x06008818 RID: 34840 RVA: 0x0022E174 File Offset: 0x0022C374
		[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: 0x06008819 RID: 34841 RVA: 0x0022E1C0 File Offset: 0x0022C3C0
		// 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, 100673687);
			HitReaction.NativeMethodInfoPtr_OnModifyOffset_Protected_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction>.NativeClassPtr, 100673688);
			HitReaction.NativeMethodInfoPtr_Hit_Public_Void_Collider_Vector3_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction>.NativeClassPtr, 100673689);
			HitReaction.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction>.NativeClassPtr, 100673690);
		}

		// Token: 0x0600881A RID: 34842 RVA: 0x001E5C80 File Offset: 0x001E3E80
		public HitReaction(IntPtr pointer)
			: base(pointer)
		{
		}

		// Token: 0x17002E53 RID: 11859
		// (get) Token: 0x0600881B RID: 34843 RVA: 0x0022E268 File Offset: 0x0022C468
		// (set) Token: 0x0600881C RID: 34844 RVA: 0x0022E29C File Offset: 0x0022C49C
		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: 0x17002E54 RID: 11860
		// (get) Token: 0x0600881D RID: 34845 RVA: 0x0022E2C4 File Offset: 0x0022C4C4
		// (set) Token: 0x0600881E RID: 34846 RVA: 0x0022E2F8 File Offset: 0x0022C4F8
		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: 0x04005AD2 RID: 23250
		private static readonly IntPtr NativeFieldInfoPtr_effectorHitPoints;

		// Token: 0x04005AD3 RID: 23251
		private static readonly IntPtr NativeFieldInfoPtr_boneHitPoints;

		// Token: 0x04005AD4 RID: 23252
		private static readonly IntPtr NativeMethodInfoPtr_get_inProgress_Public_get_Boolean_0;

		// Token: 0x04005AD5 RID: 23253
		private static readonly IntPtr NativeMethodInfoPtr_OnModifyOffset_Protected_Virtual_Void_0;

		// Token: 0x04005AD6 RID: 23254
		private static readonly IntPtr NativeMethodInfoPtr_Hit_Public_Void_Collider_Vector3_Vector3_0;

		// Token: 0x04005AD7 RID: 23255
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

		// Token: 0x0200047D RID: 1149
		[Serializable]
		public class HitPoint : Il2CppSystem.Object
		{
			// Token: 0x17002E60 RID: 11872
			// (get) Token: 0x0600881F RID: 34847 RVA: 0x0022E320 File Offset: 0x0022C520
			public unsafe bool inProgress
			{
				[CallerCount(2)]
				[CachedScanResults(RefRangeStart = 604047, RefRangeEnd = 604049, XrefRangeStart = 604047, XrefRangeEnd = 604047, 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: 0x17002E61 RID: 11873
			// (get) Token: 0x06008820 RID: 34848 RVA: 0x0022E370 File Offset: 0x0022C570
			// (set) Token: 0x06008821 RID: 34849 RVA: 0x0022E3C0 File Offset: 0x0022C5C0
			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 = 218204, RefRangeEnd = 218205, XrefRangeStart = 218204, XrefRangeEnd = 218205, 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: 0x17002E62 RID: 11874
			// (get) Token: 0x06008822 RID: 34850 RVA: 0x0022E414 File Offset: 0x0022C614
			// (set) Token: 0x06008823 RID: 34851 RVA: 0x0022E464 File Offset: 0x0022C664
			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 = 218210, RefRangeEnd = 218212, XrefRangeStart = 218210, XrefRangeEnd = 218212, 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: 0x17002E63 RID: 11875
			// (get) Token: 0x06008824 RID: 34852 RVA: 0x0022E4B8 File Offset: 0x0022C6B8
			// (set) Token: 0x06008825 RID: 34853 RVA: 0x0022E508 File Offset: 0x0022C708
			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: 0x17002E64 RID: 11876
			// (get) Token: 0x06008826 RID: 34854 RVA: 0x0022E55C File Offset: 0x0022C75C
			// (set) Token: 0x06008827 RID: 34855 RVA: 0x0022E5AC File Offset: 0x0022C7AC
			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: 0x06008828 RID: 34856 RVA: 0x0022E600 File Offset: 0x0022C800
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 604057, RefRangeEnd = 604059, XrefRangeStart = 604049, XrefRangeEnd = 604057, 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: 0x06008829 RID: 34857 RVA: 0x0022E668 File Offset: 0x0022C868
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 604064, RefRangeEnd = 604066, XrefRangeStart = 604059, XrefRangeEnd = 604064, 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: 0x0600882A RID: 34858 RVA: 0x0022E6D4 File Offset: 0x0022C8D4
			[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: 0x0600882B RID: 34859 RVA: 0x0022E730 File Offset: 0x0022C930
			[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: 0x0600882C RID: 34860 RVA: 0x0022E780 File Offset: 0x0022C980
			[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: 0x0600882D RID: 34861 RVA: 0x0022E7F8 File Offset: 0x0022C9F8
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 604066, XrefRangeEnd = 604067, 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: 0x0600882E RID: 34862 RVA: 0x0022E844 File Offset: 0x0022CA44
			// 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, 100673691);
				HitReaction.HitPoint.NativeMethodInfoPtr_get_crossFader_Protected_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100673692);
				HitReaction.HitPoint.NativeMethodInfoPtr_set_crossFader_Private_set_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100673693);
				HitReaction.HitPoint.NativeMethodInfoPtr_get_timer_Protected_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100673694);
				HitReaction.HitPoint.NativeMethodInfoPtr_set_timer_Private_set_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100673695);
				HitReaction.HitPoint.NativeMethodInfoPtr_get_force_Protected_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100673696);
				HitReaction.HitPoint.NativeMethodInfoPtr_set_force_Private_set_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100673697);
				HitReaction.HitPoint.NativeMethodInfoPtr_get_point_Protected_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100673698);
				HitReaction.HitPoint.NativeMethodInfoPtr_set_point_Private_set_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100673699);
				HitReaction.HitPoint.NativeMethodInfoPtr_Hit_Public_Void_Vector3_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100673700);
				HitReaction.HitPoint.NativeMethodInfoPtr_Apply_Public_Void_IKSolverFullBodyBiped_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100673701);
				HitReaction.HitPoint.NativeMethodInfoPtr_GetLength_Protected_Abstract_Virtual_New_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100673702);
				HitReaction.HitPoint.NativeMethodInfoPtr_CrossFadeStart_Protected_Abstract_Virtual_New_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100673703);
				HitReaction.HitPoint.NativeMethodInfoPtr_OnApply_Protected_Abstract_Virtual_New_Void_IKSolverFullBodyBiped_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100673704);
				HitReaction.HitPoint.NativeMethodInfoPtr__ctor_Protected_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100673705);
			}

			// Token: 0x0600882F RID: 34863 RVA: 0x0000A688 File Offset: 0x00008888
			public HitPoint(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002E56 RID: 11862
			// (get) Token: 0x06008830 RID: 34864 RVA: 0x0022EA64 File Offset: 0x0022CC64
			// (set) Token: 0x06008831 RID: 34865 RVA: 0x0022EA8D File Offset: 0x0022CC8D
			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: 0x17002E57 RID: 11863
			// (get) Token: 0x06008832 RID: 34866 RVA: 0x0022EAB4 File Offset: 0x0022CCB4
			// (set) Token: 0x06008833 RID: 34867 RVA: 0x0022EAE8 File Offset: 0x0022CCE8
			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: 0x17002E58 RID: 11864
			// (get) Token: 0x06008834 RID: 34868 RVA: 0x0022EB10 File Offset: 0x0022CD10
			// (set) Token: 0x06008835 RID: 34869 RVA: 0x0022EB38 File Offset: 0x0022CD38
			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: 0x17002E59 RID: 11865
			// (get) Token: 0x06008836 RID: 34870 RVA: 0x0022EB5C File Offset: 0x0022CD5C
			// (set) Token: 0x06008837 RID: 34871 RVA: 0x0022EB84 File Offset: 0x0022CD84
			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: 0x17002E5A RID: 11866
			// (get) Token: 0x06008838 RID: 34872 RVA: 0x0022EBA8 File Offset: 0x0022CDA8
			// (set) Token: 0x06008839 RID: 34873 RVA: 0x0022EBD0 File Offset: 0x0022CDD0
			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: 0x17002E5B RID: 11867
			// (get) Token: 0x0600883A RID: 34874 RVA: 0x0022EBF4 File Offset: 0x0022CDF4
			// (set) Token: 0x0600883B RID: 34875 RVA: 0x0022EC1C File Offset: 0x0022CE1C
			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: 0x17002E5C RID: 11868
			// (get) Token: 0x0600883C RID: 34876 RVA: 0x0022EC40 File Offset: 0x0022CE40
			// (set) Token: 0x0600883D RID: 34877 RVA: 0x0022EC68 File Offset: 0x0022CE68
			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: 0x17002E5D RID: 11869
			// (get) Token: 0x0600883E RID: 34878 RVA: 0x0022EC8C File Offset: 0x0022CE8C
			// (set) Token: 0x0600883F RID: 34879 RVA: 0x0022ECB4 File Offset: 0x0022CEB4
			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: 0x17002E5E RID: 11870
			// (get) Token: 0x06008840 RID: 34880 RVA: 0x0022ECD8 File Offset: 0x0022CED8
			// (set) Token: 0x06008841 RID: 34881 RVA: 0x0022ED00 File Offset: 0x0022CF00
			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: 0x17002E5F RID: 11871
			// (get) Token: 0x06008842 RID: 34882 RVA: 0x0022ED24 File Offset: 0x0022CF24
			// (set) Token: 0x06008843 RID: 34883 RVA: 0x0022ED4C File Offset: 0x0022CF4C
			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: 0x04005AD8 RID: 23256
			private static readonly IntPtr NativeFieldInfoPtr_name;

			// Token: 0x04005AD9 RID: 23257
			private static readonly IntPtr NativeFieldInfoPtr_collider;

			// Token: 0x04005ADA RID: 23258
			private static readonly IntPtr NativeFieldInfoPtr_crossFadeTime;

			// Token: 0x04005ADB RID: 23259
			private static readonly IntPtr NativeFieldInfoPtr__crossFader_k__BackingField;

			// Token: 0x04005ADC RID: 23260
			private static readonly IntPtr NativeFieldInfoPtr__timer_k__BackingField;

			// Token: 0x04005ADD RID: 23261
			private static readonly IntPtr NativeFieldInfoPtr__force_k__BackingField;

			// Token: 0x04005ADE RID: 23262
			private static readonly IntPtr NativeFieldInfoPtr__point_k__BackingField;

			// Token: 0x04005ADF RID: 23263
			private static readonly IntPtr NativeFieldInfoPtr_length;

			// Token: 0x04005AE0 RID: 23264
			private static readonly IntPtr NativeFieldInfoPtr_crossFadeSpeed;

			// Token: 0x04005AE1 RID: 23265
			private static readonly IntPtr NativeFieldInfoPtr_lastTime;

			// Token: 0x04005AE2 RID: 23266
			private static readonly IntPtr NativeMethodInfoPtr_get_inProgress_Public_get_Boolean_0;

			// Token: 0x04005AE3 RID: 23267
			private static readonly IntPtr NativeMethodInfoPtr_get_crossFader_Protected_get_Single_0;

			// Token: 0x04005AE4 RID: 23268
			private static readonly IntPtr NativeMethodInfoPtr_set_crossFader_Private_set_Void_Single_0;

			// Token: 0x04005AE5 RID: 23269
			private static readonly IntPtr NativeMethodInfoPtr_get_timer_Protected_get_Single_0;

			// Token: 0x04005AE6 RID: 23270
			private static readonly IntPtr NativeMethodInfoPtr_set_timer_Private_set_Void_Single_0;

			// Token: 0x04005AE7 RID: 23271
			private static readonly IntPtr NativeMethodInfoPtr_get_force_Protected_get_Vector3_0;

			// Token: 0x04005AE8 RID: 23272
			private static readonly IntPtr NativeMethodInfoPtr_set_force_Private_set_Void_Vector3_0;

			// Token: 0x04005AE9 RID: 23273
			private static readonly IntPtr NativeMethodInfoPtr_get_point_Protected_get_Vector3_0;

			// Token: 0x04005AEA RID: 23274
			private static readonly IntPtr NativeMethodInfoPtr_set_point_Private_set_Void_Vector3_0;

			// Token: 0x04005AEB RID: 23275
			private static readonly IntPtr NativeMethodInfoPtr_Hit_Public_Void_Vector3_Vector3_0;

			// Token: 0x04005AEC RID: 23276
			private static readonly IntPtr NativeMethodInfoPtr_Apply_Public_Void_IKSolverFullBodyBiped_Single_0;

			// Token: 0x04005AED RID: 23277
			private static readonly IntPtr NativeMethodInfoPtr_GetLength_Protected_Abstract_Virtual_New_Single_0;

			// Token: 0x04005AEE RID: 23278
			private static readonly IntPtr NativeMethodInfoPtr_CrossFadeStart_Protected_Abstract_Virtual_New_Void_0;

			// Token: 0x04005AEF RID: 23279
			private static readonly IntPtr NativeMethodInfoPtr_OnApply_Protected_Abstract_Virtual_New_Void_IKSolverFullBodyBiped_Single_0;

			// Token: 0x04005AF0 RID: 23280
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Protected_Void_0;
		}

		// Token: 0x0200047E RID: 1150
		[Serializable]
		public class HitPointEffector : HitReaction.HitPoint
		{
			// Token: 0x06008844 RID: 34884 RVA: 0x0022ED70 File Offset: 0x0022CF70
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 604072, XrefRangeEnd = 604087, 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: 0x06008845 RID: 34885 RVA: 0x0022EDCC File Offset: 0x0022CFCC
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 604087, XrefRangeEnd = 604089, 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: 0x06008846 RID: 34886 RVA: 0x0022EE1C File Offset: 0x0022D01C
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 604089, XrefRangeEnd = 604095, 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: 0x06008847 RID: 34887 RVA: 0x0022EE94 File Offset: 0x0022D094
			[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: 0x06008848 RID: 34888 RVA: 0x0022EEE0 File Offset: 0x0022D0E0
			// 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, 100673706);
				HitReaction.HitPointEffector.NativeMethodInfoPtr_CrossFadeStart_Protected_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPointEffector>.NativeClassPtr, 100673707);
				HitReaction.HitPointEffector.NativeMethodInfoPtr_OnApply_Protected_Virtual_Void_IKSolverFullBodyBiped_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPointEffector>.NativeClassPtr, 100673708);
				HitReaction.HitPointEffector.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPointEffector>.NativeClassPtr, 100673709);
			}

			// Token: 0x06008849 RID: 34889 RVA: 0x0022EF97 File Offset: 0x0022D197
			public HitPointEffector(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002E65 RID: 11877
			// (get) Token: 0x0600884A RID: 34890 RVA: 0x0022EFA0 File Offset: 0x0022D1A0
			// (set) Token: 0x0600884B RID: 34891 RVA: 0x0022EFD4 File Offset: 0x0022D1D4
			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: 0x17002E66 RID: 11878
			// (get) Token: 0x0600884C RID: 34892 RVA: 0x0022EFFC File Offset: 0x0022D1FC
			// (set) Token: 0x0600884D RID: 34893 RVA: 0x0022F030 File Offset: 0x0022D230
			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: 0x17002E67 RID: 11879
			// (get) Token: 0x0600884E RID: 34894 RVA: 0x0022F058 File Offset: 0x0022D258
			// (set) Token: 0x0600884F RID: 34895 RVA: 0x0022F08C File Offset: 0x0022D28C
			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: 0x04005AF1 RID: 23281
			private static readonly IntPtr NativeFieldInfoPtr_offsetInForceDirection;

			// Token: 0x04005AF2 RID: 23282
			private static readonly IntPtr NativeFieldInfoPtr_offsetInUpDirection;

			// Token: 0x04005AF3 RID: 23283
			private static readonly IntPtr NativeFieldInfoPtr_effectorLinks;

			// Token: 0x04005AF4 RID: 23284
			private static readonly IntPtr NativeMethodInfoPtr_GetLength_Protected_Virtual_Single_0;

			// Token: 0x04005AF5 RID: 23285
			private static readonly IntPtr NativeMethodInfoPtr_CrossFadeStart_Protected_Virtual_Void_0;

			// Token: 0x04005AF6 RID: 23286
			private static readonly IntPtr NativeMethodInfoPtr_OnApply_Protected_Virtual_Void_IKSolverFullBodyBiped_Single_0;

			// Token: 0x04005AF7 RID: 23287
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

			// Token: 0x0200047F RID: 1151
			[Serializable]
			public class EffectorLink : Il2CppSystem.Object
			{
				// Token: 0x06008850 RID: 34896 RVA: 0x0022F0B4 File Offset: 0x0022D2B4
				[CallerCount(1)]
				[CachedScanResults(RefRangeStart = 604069, RefRangeEnd = 604070, XrefRangeStart = 604067, XrefRangeEnd = 604069, 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: 0x06008851 RID: 34897 RVA: 0x0022F134 File Offset: 0x0022D334
				[CallerCount(2)]
				[CachedScanResults(RefRangeStart = 604070, RefRangeEnd = 604072, XrefRangeStart = 604070, XrefRangeEnd = 604070, 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: 0x06008852 RID: 34898 RVA: 0x0022F178 File Offset: 0x0022D378
				[CallerCount(1642)]
				[CachedScanResults(RefRangeStart = 7417, RefRangeEnd = 9059, XrefRangeStart = 7417, XrefRangeEnd = 9059, 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: 0x06008853 RID: 34899 RVA: 0x0022F1C4 File Offset: 0x0022D3C4
				// 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, 100673710);
					HitReaction.HitPointEffector.EffectorLink.NativeMethodInfoPtr_CrossFadeStart_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPointEffector.EffectorLink>.NativeClassPtr, 100673711);
					HitReaction.HitPointEffector.EffectorLink.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPointEffector.EffectorLink>.NativeClassPtr, 100673712);
				}

				// Token: 0x06008854 RID: 34900 RVA: 0x0000A688 File Offset: 0x00008888
				public EffectorLink(IntPtr pointer)
					: base(pointer)
				{
				}

				// Token: 0x17002E68 RID: 11880
				// (get) Token: 0x06008855 RID: 34901 RVA: 0x0022F27C File Offset: 0x0022D47C
				// (set) Token: 0x06008856 RID: 34902 RVA: 0x0022F2A4 File Offset: 0x0022D4A4
				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: 0x17002E69 RID: 11881
				// (get) Token: 0x06008857 RID: 34903 RVA: 0x0022F2C8 File Offset: 0x0022D4C8
				// (set) Token: 0x06008858 RID: 34904 RVA: 0x0022F2F0 File Offset: 0x0022D4F0
				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: 0x17002E6A RID: 11882
				// (get) Token: 0x06008859 RID: 34905 RVA: 0x0022F314 File Offset: 0x0022D514
				// (set) Token: 0x0600885A RID: 34906 RVA: 0x0022F33C File Offset: 0x0022D53C
				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: 0x17002E6B RID: 11883
				// (get) Token: 0x0600885B RID: 34907 RVA: 0x0022F360 File Offset: 0x0022D560
				// (set) Token: 0x0600885C RID: 34908 RVA: 0x0022F388 File Offset: 0x0022D588
				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: 0x04005AF8 RID: 23288
				private static readonly IntPtr NativeFieldInfoPtr_effector;

				// Token: 0x04005AF9 RID: 23289
				private static readonly IntPtr NativeFieldInfoPtr_weight;

				// Token: 0x04005AFA RID: 23290
				private static readonly IntPtr NativeFieldInfoPtr_lastValue;

				// Token: 0x04005AFB RID: 23291
				private static readonly IntPtr NativeFieldInfoPtr_current;

				// Token: 0x04005AFC RID: 23292
				private static readonly IntPtr NativeMethodInfoPtr_Apply_Public_Void_IKSolverFullBodyBiped_Vector3_Single_0;

				// Token: 0x04005AFD RID: 23293
				private static readonly IntPtr NativeMethodInfoPtr_CrossFadeStart_Public_Void_0;

				// Token: 0x04005AFE RID: 23294
				private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
			}
		}

		// Token: 0x02000480 RID: 1152
		[Serializable]
		public class HitPointBone : HitReaction.HitPoint
		{
			// Token: 0x0600885D RID: 34909 RVA: 0x0022F3AC File Offset: 0x0022D5AC
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 604106, XrefRangeEnd = 604110, 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: 0x0600885E RID: 34910 RVA: 0x0022F408 File Offset: 0x0022D608
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 604110, XrefRangeEnd = 604112, 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: 0x0600885F RID: 34911 RVA: 0x0022F458 File Offset: 0x0022D658
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 604112, XrefRangeEnd = 604129, 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: 0x06008860 RID: 34912 RVA: 0x0022F4D0 File Offset: 0x0022D6D0
			[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: 0x06008861 RID: 34913 RVA: 0x0022F51C File Offset: 0x0022D71C
			// 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, 100673713);
				HitReaction.HitPointBone.NativeMethodInfoPtr_CrossFadeStart_Protected_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPointBone>.NativeClassPtr, 100673714);
				HitReaction.HitPointBone.NativeMethodInfoPtr_OnApply_Protected_Virtual_Void_IKSolverFullBodyBiped_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPointBone>.NativeClassPtr, 100673715);
				HitReaction.HitPointBone.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPointBone>.NativeClassPtr, 100673716);
			}

			// Token: 0x06008862 RID: 34914 RVA: 0x0022EF97 File Offset: 0x0022D197
			public HitPointBone(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002E6C RID: 11884
			// (get) Token: 0x06008863 RID: 34915 RVA: 0x0022F5D4 File Offset: 0x0022D7D4
			// (set) Token: 0x06008864 RID: 34916 RVA: 0x0022F608 File Offset: 0x0022D808
			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: 0x17002E6D RID: 11885
			// (get) Token: 0x06008865 RID: 34917 RVA: 0x0022F630 File Offset: 0x0022D830
			// (set) Token: 0x06008866 RID: 34918 RVA: 0x0022F664 File Offset: 0x0022D864
			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: 0x17002E6E RID: 11886
			// (get) Token: 0x06008867 RID: 34919 RVA: 0x0022F68C File Offset: 0x0022D88C
			// (set) Token: 0x06008868 RID: 34920 RVA: 0x0022F6C0 File Offset: 0x0022D8C0
			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: 0x04005AFF RID: 23295
			private static readonly IntPtr NativeFieldInfoPtr_aroundCenterOfMass;

			// Token: 0x04005B00 RID: 23296
			private static readonly IntPtr NativeFieldInfoPtr_boneLinks;

			// Token: 0x04005B01 RID: 23297
			private static readonly IntPtr NativeFieldInfoPtr_rigidbody;

			// Token: 0x04005B02 RID: 23298
			private static readonly IntPtr NativeMethodInfoPtr_GetLength_Protected_Virtual_Single_0;

			// Token: 0x04005B03 RID: 23299
			private static readonly IntPtr NativeMethodInfoPtr_CrossFadeStart_Protected_Virtual_Void_0;

			// Token: 0x04005B04 RID: 23300
			private static readonly IntPtr NativeMethodInfoPtr_OnApply_Protected_Virtual_Void_IKSolverFullBodyBiped_Single_0;

			// Token: 0x04005B05 RID: 23301
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

			// Token: 0x02000481 RID: 1153
			[Serializable]
			public class BoneLink : Il2CppSystem.Object
			{
				// Token: 0x06008869 RID: 34921 RVA: 0x0022F6E8 File Offset: 0x0022D8E8
				[CallerCount(1)]
				[CachedScanResults(RefRangeStart = 604101, RefRangeEnd = 604102, XrefRangeStart = 604095, XrefRangeEnd = 604101, 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: 0x0600886A RID: 34922 RVA: 0x0022F768 File Offset: 0x0022D968
				[CallerCount(1)]
				[CachedScanResults(RefRangeStart = 604102, RefRangeEnd = 604103, XrefRangeStart = 604102, XrefRangeEnd = 604102, 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: 0x0600886B RID: 34923 RVA: 0x0022F7AC File Offset: 0x0022D9AC
				[CallerCount(0)]
				[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 604103, XrefRangeEnd = 604106, 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: 0x0600886C RID: 34924 RVA: 0x0022F7F8 File Offset: 0x0022D9F8
				// 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, 100673717);
					HitReaction.HitPointBone.BoneLink.NativeMethodInfoPtr_CrossFadeStart_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPointBone.BoneLink>.NativeClassPtr, 100673718);
					HitReaction.HitPointBone.BoneLink.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPointBone.BoneLink>.NativeClassPtr, 100673719);
				}

				// Token: 0x0600886D RID: 34925 RVA: 0x0000A688 File Offset: 0x00008888
				public BoneLink(IntPtr pointer)
					: base(pointer)
				{
				}

				// Token: 0x17002E6F RID: 11887
				// (get) Token: 0x0600886E RID: 34926 RVA: 0x0022F8B0 File Offset: 0x0022DAB0
				// (set) Token: 0x0600886F RID: 34927 RVA: 0x0022F8E4 File Offset: 0x0022DAE4
				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: 0x17002E70 RID: 11888
				// (get) Token: 0x06008870 RID: 34928 RVA: 0x0022F90C File Offset: 0x0022DB0C
				// (set) Token: 0x06008871 RID: 34929 RVA: 0x0022F934 File Offset: 0x0022DB34
				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: 0x17002E71 RID: 11889
				// (get) Token: 0x06008872 RID: 34930 RVA: 0x0022F958 File Offset: 0x0022DB58
				// (set) Token: 0x06008873 RID: 34931 RVA: 0x0022F980 File Offset: 0x0022DB80
				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: 0x17002E72 RID: 11890
				// (get) Token: 0x06008874 RID: 34932 RVA: 0x0022F9A4 File Offset: 0x0022DBA4
				// (set) Token: 0x06008875 RID: 34933 RVA: 0x0022F9CC File Offset: 0x0022DBCC
				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: 0x04005B06 RID: 23302
				private static readonly IntPtr NativeFieldInfoPtr_bone;

				// Token: 0x04005B07 RID: 23303
				private static readonly IntPtr NativeFieldInfoPtr_weight;

				// Token: 0x04005B08 RID: 23304
				private static readonly IntPtr NativeFieldInfoPtr_lastValue;

				// Token: 0x04005B09 RID: 23305
				private static readonly IntPtr NativeFieldInfoPtr_current;

				// Token: 0x04005B0A RID: 23306
				private static readonly IntPtr NativeMethodInfoPtr_Apply_Public_Void_IKSolverFullBodyBiped_Quaternion_Single_0;

				// Token: 0x04005B0B RID: 23307
				private static readonly IntPtr NativeMethodInfoPtr_CrossFadeStart_Public_Void_0;

				// Token: 0x04005B0C RID: 23308
				private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
			}
		}
	}
}