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

namespace RootMotion.FinalIK
{
	// Token: 0x02000485 RID: 1157
	public class HitReaction : OffsetModifier
	{
		// Token: 0x17002E87 RID: 11911
		// (get) Token: 0x060088C5 RID: 35013 RVA: 0x00230C58 File Offset: 0x0022EE58
		public unsafe bool inProgress
		{
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 621860, XrefRangeEnd = 621864, 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: 0x060088C6 RID: 35014 RVA: 0x00230CA8 File Offset: 0x0022EEA8
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 621864, XrefRangeEnd = 621868, 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: 0x060088C7 RID: 35015 RVA: 0x00230CF8 File Offset: 0x0022EEF8
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 621888, RefRangeEnd = 621889, XrefRangeStart = 621868, XrefRangeEnd = 621888, 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: 0x060088C8 RID: 35016 RVA: 0x00230D78 File Offset: 0x0022EF78
		[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: 0x060088C9 RID: 35017 RVA: 0x00230DC4 File Offset: 0x0022EFC4
		// 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, 100673737);
			HitReaction.NativeMethodInfoPtr_OnModifyOffset_Protected_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction>.NativeClassPtr, 100673738);
			HitReaction.NativeMethodInfoPtr_Hit_Public_Void_Collider_Vector3_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction>.NativeClassPtr, 100673739);
			HitReaction.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction>.NativeClassPtr, 100673740);
		}

		// Token: 0x060088CA RID: 35018 RVA: 0x001E8884 File Offset: 0x001E6A84
		public HitReaction(IntPtr pointer)
			: base(pointer)
		{
		}

		// Token: 0x17002E85 RID: 11909
		// (get) Token: 0x060088CB RID: 35019 RVA: 0x00230E6C File Offset: 0x0022F06C
		// (set) Token: 0x060088CC RID: 35020 RVA: 0x00230EA0 File Offset: 0x0022F0A0
		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: 0x17002E86 RID: 11910
		// (get) Token: 0x060088CD RID: 35021 RVA: 0x00230EC8 File Offset: 0x0022F0C8
		// (set) Token: 0x060088CE RID: 35022 RVA: 0x00230EFC File Offset: 0x0022F0FC
		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: 0x04005B46 RID: 23366
		private static readonly IntPtr NativeFieldInfoPtr_effectorHitPoints;

		// Token: 0x04005B47 RID: 23367
		private static readonly IntPtr NativeFieldInfoPtr_boneHitPoints;

		// Token: 0x04005B48 RID: 23368
		private static readonly IntPtr NativeMethodInfoPtr_get_inProgress_Public_get_Boolean_0;

		// Token: 0x04005B49 RID: 23369
		private static readonly IntPtr NativeMethodInfoPtr_OnModifyOffset_Protected_Virtual_Void_0;

		// Token: 0x04005B4A RID: 23370
		private static readonly IntPtr NativeMethodInfoPtr_Hit_Public_Void_Collider_Vector3_Vector3_0;

		// Token: 0x04005B4B RID: 23371
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

		// Token: 0x02000486 RID: 1158
		[Serializable]
		public class HitPoint : Il2CppSystem.Object
		{
			// Token: 0x17002E92 RID: 11922
			// (get) Token: 0x060088CF RID: 35023 RVA: 0x00230F24 File Offset: 0x0022F124
			public unsafe bool inProgress
			{
				[CallerCount(2)]
				[CachedScanResults(RefRangeStart = 621778, RefRangeEnd = 621780, XrefRangeStart = 621778, XrefRangeEnd = 621778, 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: 0x17002E93 RID: 11923
			// (get) Token: 0x060088D0 RID: 35024 RVA: 0x00230F74 File Offset: 0x0022F174
			// (set) Token: 0x060088D1 RID: 35025 RVA: 0x00230FC4 File Offset: 0x0022F1C4
			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 = 223831, RefRangeEnd = 223832, XrefRangeStart = 223831, XrefRangeEnd = 223832, 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: 0x17002E94 RID: 11924
			// (get) Token: 0x060088D2 RID: 35026 RVA: 0x00231018 File Offset: 0x0022F218
			// (set) Token: 0x060088D3 RID: 35027 RVA: 0x00231068 File Offset: 0x0022F268
			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 = 223837, RefRangeEnd = 223839, XrefRangeStart = 223837, XrefRangeEnd = 223839, 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: 0x17002E95 RID: 11925
			// (get) Token: 0x060088D4 RID: 35028 RVA: 0x002310BC File Offset: 0x0022F2BC
			// (set) Token: 0x060088D5 RID: 35029 RVA: 0x0023110C File Offset: 0x0022F30C
			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: 0x17002E96 RID: 11926
			// (get) Token: 0x060088D6 RID: 35030 RVA: 0x00231160 File Offset: 0x0022F360
			// (set) Token: 0x060088D7 RID: 35031 RVA: 0x002311B0 File Offset: 0x0022F3B0
			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: 0x060088D8 RID: 35032 RVA: 0x00231204 File Offset: 0x0022F404
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 621788, RefRangeEnd = 621790, XrefRangeStart = 621780, XrefRangeEnd = 621788, 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: 0x060088D9 RID: 35033 RVA: 0x0023126C File Offset: 0x0022F46C
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 621795, RefRangeEnd = 621797, XrefRangeStart = 621790, XrefRangeEnd = 621795, 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: 0x060088DA RID: 35034 RVA: 0x002312D8 File Offset: 0x0022F4D8
			[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: 0x060088DB RID: 35035 RVA: 0x00231334 File Offset: 0x0022F534
			[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: 0x060088DC RID: 35036 RVA: 0x00231384 File Offset: 0x0022F584
			[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: 0x060088DD RID: 35037 RVA: 0x002313FC File Offset: 0x0022F5FC
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 621797, XrefRangeEnd = 621798, 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: 0x060088DE RID: 35038 RVA: 0x00231448 File Offset: 0x0022F648
			// 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, 100673741);
				HitReaction.HitPoint.NativeMethodInfoPtr_get_crossFader_Protected_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100673742);
				HitReaction.HitPoint.NativeMethodInfoPtr_set_crossFader_Private_set_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100673743);
				HitReaction.HitPoint.NativeMethodInfoPtr_get_timer_Protected_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100673744);
				HitReaction.HitPoint.NativeMethodInfoPtr_set_timer_Private_set_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100673745);
				HitReaction.HitPoint.NativeMethodInfoPtr_get_force_Protected_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100673746);
				HitReaction.HitPoint.NativeMethodInfoPtr_set_force_Private_set_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100673747);
				HitReaction.HitPoint.NativeMethodInfoPtr_get_point_Protected_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100673748);
				HitReaction.HitPoint.NativeMethodInfoPtr_set_point_Private_set_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100673749);
				HitReaction.HitPoint.NativeMethodInfoPtr_Hit_Public_Void_Vector3_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100673750);
				HitReaction.HitPoint.NativeMethodInfoPtr_Apply_Public_Void_IKSolverFullBodyBiped_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100673751);
				HitReaction.HitPoint.NativeMethodInfoPtr_GetLength_Protected_Abstract_Virtual_New_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100673752);
				HitReaction.HitPoint.NativeMethodInfoPtr_CrossFadeStart_Protected_Abstract_Virtual_New_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100673753);
				HitReaction.HitPoint.NativeMethodInfoPtr_OnApply_Protected_Abstract_Virtual_New_Void_IKSolverFullBodyBiped_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100673754);
				HitReaction.HitPoint.NativeMethodInfoPtr__ctor_Protected_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPoint>.NativeClassPtr, 100673755);
			}

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

			// Token: 0x17002E88 RID: 11912
			// (get) Token: 0x060088E0 RID: 35040 RVA: 0x00231668 File Offset: 0x0022F868
			// (set) Token: 0x060088E1 RID: 35041 RVA: 0x00231691 File Offset: 0x0022F891
			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: 0x17002E89 RID: 11913
			// (get) Token: 0x060088E2 RID: 35042 RVA: 0x002316B8 File Offset: 0x0022F8B8
			// (set) Token: 0x060088E3 RID: 35043 RVA: 0x002316EC File Offset: 0x0022F8EC
			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: 0x17002E8A RID: 11914
			// (get) Token: 0x060088E4 RID: 35044 RVA: 0x00231714 File Offset: 0x0022F914
			// (set) Token: 0x060088E5 RID: 35045 RVA: 0x0023173C File Offset: 0x0022F93C
			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: 0x17002E8B RID: 11915
			// (get) Token: 0x060088E6 RID: 35046 RVA: 0x00231760 File Offset: 0x0022F960
			// (set) Token: 0x060088E7 RID: 35047 RVA: 0x00231788 File Offset: 0x0022F988
			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: 0x17002E8C RID: 11916
			// (get) Token: 0x060088E8 RID: 35048 RVA: 0x002317AC File Offset: 0x0022F9AC
			// (set) Token: 0x060088E9 RID: 35049 RVA: 0x002317D4 File Offset: 0x0022F9D4
			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: 0x17002E8D RID: 11917
			// (get) Token: 0x060088EA RID: 35050 RVA: 0x002317F8 File Offset: 0x0022F9F8
			// (set) Token: 0x060088EB RID: 35051 RVA: 0x00231820 File Offset: 0x0022FA20
			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: 0x17002E8E RID: 11918
			// (get) Token: 0x060088EC RID: 35052 RVA: 0x00231844 File Offset: 0x0022FA44
			// (set) Token: 0x060088ED RID: 35053 RVA: 0x0023186C File Offset: 0x0022FA6C
			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: 0x17002E8F RID: 11919
			// (get) Token: 0x060088EE RID: 35054 RVA: 0x00231890 File Offset: 0x0022FA90
			// (set) Token: 0x060088EF RID: 35055 RVA: 0x002318B8 File Offset: 0x0022FAB8
			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: 0x17002E90 RID: 11920
			// (get) Token: 0x060088F0 RID: 35056 RVA: 0x002318DC File Offset: 0x0022FADC
			// (set) Token: 0x060088F1 RID: 35057 RVA: 0x00231904 File Offset: 0x0022FB04
			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: 0x17002E91 RID: 11921
			// (get) Token: 0x060088F2 RID: 35058 RVA: 0x00231928 File Offset: 0x0022FB28
			// (set) Token: 0x060088F3 RID: 35059 RVA: 0x00231950 File Offset: 0x0022FB50
			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: 0x04005B4C RID: 23372
			private static readonly IntPtr NativeFieldInfoPtr_name;

			// Token: 0x04005B4D RID: 23373
			private static readonly IntPtr NativeFieldInfoPtr_collider;

			// Token: 0x04005B4E RID: 23374
			private static readonly IntPtr NativeFieldInfoPtr_crossFadeTime;

			// Token: 0x04005B4F RID: 23375
			private static readonly IntPtr NativeFieldInfoPtr__crossFader_k__BackingField;

			// Token: 0x04005B50 RID: 23376
			private static readonly IntPtr NativeFieldInfoPtr__timer_k__BackingField;

			// Token: 0x04005B51 RID: 23377
			private static readonly IntPtr NativeFieldInfoPtr__force_k__BackingField;

			// Token: 0x04005B52 RID: 23378
			private static readonly IntPtr NativeFieldInfoPtr__point_k__BackingField;

			// Token: 0x04005B53 RID: 23379
			private static readonly IntPtr NativeFieldInfoPtr_length;

			// Token: 0x04005B54 RID: 23380
			private static readonly IntPtr NativeFieldInfoPtr_crossFadeSpeed;

			// Token: 0x04005B55 RID: 23381
			private static readonly IntPtr NativeFieldInfoPtr_lastTime;

			// Token: 0x04005B56 RID: 23382
			private static readonly IntPtr NativeMethodInfoPtr_get_inProgress_Public_get_Boolean_0;

			// Token: 0x04005B57 RID: 23383
			private static readonly IntPtr NativeMethodInfoPtr_get_crossFader_Protected_get_Single_0;

			// Token: 0x04005B58 RID: 23384
			private static readonly IntPtr NativeMethodInfoPtr_set_crossFader_Private_set_Void_Single_0;

			// Token: 0x04005B59 RID: 23385
			private static readonly IntPtr NativeMethodInfoPtr_get_timer_Protected_get_Single_0;

			// Token: 0x04005B5A RID: 23386
			private static readonly IntPtr NativeMethodInfoPtr_set_timer_Private_set_Void_Single_0;

			// Token: 0x04005B5B RID: 23387
			private static readonly IntPtr NativeMethodInfoPtr_get_force_Protected_get_Vector3_0;

			// Token: 0x04005B5C RID: 23388
			private static readonly IntPtr NativeMethodInfoPtr_set_force_Private_set_Void_Vector3_0;

			// Token: 0x04005B5D RID: 23389
			private static readonly IntPtr NativeMethodInfoPtr_get_point_Protected_get_Vector3_0;

			// Token: 0x04005B5E RID: 23390
			private static readonly IntPtr NativeMethodInfoPtr_set_point_Private_set_Void_Vector3_0;

			// Token: 0x04005B5F RID: 23391
			private static readonly IntPtr NativeMethodInfoPtr_Hit_Public_Void_Vector3_Vector3_0;

			// Token: 0x04005B60 RID: 23392
			private static readonly IntPtr NativeMethodInfoPtr_Apply_Public_Void_IKSolverFullBodyBiped_Single_0;

			// Token: 0x04005B61 RID: 23393
			private static readonly IntPtr NativeMethodInfoPtr_GetLength_Protected_Abstract_Virtual_New_Single_0;

			// Token: 0x04005B62 RID: 23394
			private static readonly IntPtr NativeMethodInfoPtr_CrossFadeStart_Protected_Abstract_Virtual_New_Void_0;

			// Token: 0x04005B63 RID: 23395
			private static readonly IntPtr NativeMethodInfoPtr_OnApply_Protected_Abstract_Virtual_New_Void_IKSolverFullBodyBiped_Single_0;

			// Token: 0x04005B64 RID: 23396
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Protected_Void_0;
		}

		// Token: 0x02000487 RID: 1159
		[Serializable]
		public class HitPointEffector : HitReaction.HitPoint
		{
			// Token: 0x060088F4 RID: 35060 RVA: 0x00231974 File Offset: 0x0022FB74
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 621803, XrefRangeEnd = 621818, 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: 0x060088F5 RID: 35061 RVA: 0x002319D0 File Offset: 0x0022FBD0
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 621818, XrefRangeEnd = 621820, 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: 0x060088F6 RID: 35062 RVA: 0x00231A20 File Offset: 0x0022FC20
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 621820, XrefRangeEnd = 621826, 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: 0x060088F7 RID: 35063 RVA: 0x00231A98 File Offset: 0x0022FC98
			[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: 0x060088F8 RID: 35064 RVA: 0x00231AE4 File Offset: 0x0022FCE4
			// 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, 100673756);
				HitReaction.HitPointEffector.NativeMethodInfoPtr_CrossFadeStart_Protected_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPointEffector>.NativeClassPtr, 100673757);
				HitReaction.HitPointEffector.NativeMethodInfoPtr_OnApply_Protected_Virtual_Void_IKSolverFullBodyBiped_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPointEffector>.NativeClassPtr, 100673758);
				HitReaction.HitPointEffector.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPointEffector>.NativeClassPtr, 100673759);
			}

			// Token: 0x060088F9 RID: 35065 RVA: 0x00231B9B File Offset: 0x0022FD9B
			public HitPointEffector(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002E97 RID: 11927
			// (get) Token: 0x060088FA RID: 35066 RVA: 0x00231BA4 File Offset: 0x0022FDA4
			// (set) Token: 0x060088FB RID: 35067 RVA: 0x00231BD8 File Offset: 0x0022FDD8
			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: 0x17002E98 RID: 11928
			// (get) Token: 0x060088FC RID: 35068 RVA: 0x00231C00 File Offset: 0x0022FE00
			// (set) Token: 0x060088FD RID: 35069 RVA: 0x00231C34 File Offset: 0x0022FE34
			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: 0x17002E99 RID: 11929
			// (get) Token: 0x060088FE RID: 35070 RVA: 0x00231C5C File Offset: 0x0022FE5C
			// (set) Token: 0x060088FF RID: 35071 RVA: 0x00231C90 File Offset: 0x0022FE90
			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: 0x04005B65 RID: 23397
			private static readonly IntPtr NativeFieldInfoPtr_offsetInForceDirection;

			// Token: 0x04005B66 RID: 23398
			private static readonly IntPtr NativeFieldInfoPtr_offsetInUpDirection;

			// Token: 0x04005B67 RID: 23399
			private static readonly IntPtr NativeFieldInfoPtr_effectorLinks;

			// Token: 0x04005B68 RID: 23400
			private static readonly IntPtr NativeMethodInfoPtr_GetLength_Protected_Virtual_Single_0;

			// Token: 0x04005B69 RID: 23401
			private static readonly IntPtr NativeMethodInfoPtr_CrossFadeStart_Protected_Virtual_Void_0;

			// Token: 0x04005B6A RID: 23402
			private static readonly IntPtr NativeMethodInfoPtr_OnApply_Protected_Virtual_Void_IKSolverFullBodyBiped_Single_0;

			// Token: 0x04005B6B RID: 23403
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

			// Token: 0x02000488 RID: 1160
			[Serializable]
			public class EffectorLink : Il2CppSystem.Object
			{
				// Token: 0x06008900 RID: 35072 RVA: 0x00231CB8 File Offset: 0x0022FEB8
				[CallerCount(1)]
				[CachedScanResults(RefRangeStart = 621800, RefRangeEnd = 621801, XrefRangeStart = 621798, XrefRangeEnd = 621800, 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: 0x06008901 RID: 35073 RVA: 0x00231D38 File Offset: 0x0022FF38
				[CallerCount(2)]
				[CachedScanResults(RefRangeStart = 621801, RefRangeEnd = 621803, XrefRangeStart = 621801, XrefRangeEnd = 621801, 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: 0x06008902 RID: 35074 RVA: 0x00231D7C File Offset: 0x0022FF7C
				[CallerCount(1659)]
				[CachedScanResults(RefRangeStart = 7639, RefRangeEnd = 9298, XrefRangeStart = 7639, XrefRangeEnd = 9298, 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: 0x06008903 RID: 35075 RVA: 0x00231DC8 File Offset: 0x0022FFC8
				// 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, 100673760);
					HitReaction.HitPointEffector.EffectorLink.NativeMethodInfoPtr_CrossFadeStart_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPointEffector.EffectorLink>.NativeClassPtr, 100673761);
					HitReaction.HitPointEffector.EffectorLink.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPointEffector.EffectorLink>.NativeClassPtr, 100673762);
				}

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

				// Token: 0x17002E9A RID: 11930
				// (get) Token: 0x06008905 RID: 35077 RVA: 0x00231E80 File Offset: 0x00230080
				// (set) Token: 0x06008906 RID: 35078 RVA: 0x00231EA8 File Offset: 0x002300A8
				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: 0x17002E9B RID: 11931
				// (get) Token: 0x06008907 RID: 35079 RVA: 0x00231ECC File Offset: 0x002300CC
				// (set) Token: 0x06008908 RID: 35080 RVA: 0x00231EF4 File Offset: 0x002300F4
				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: 0x17002E9C RID: 11932
				// (get) Token: 0x06008909 RID: 35081 RVA: 0x00231F18 File Offset: 0x00230118
				// (set) Token: 0x0600890A RID: 35082 RVA: 0x00231F40 File Offset: 0x00230140
				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: 0x17002E9D RID: 11933
				// (get) Token: 0x0600890B RID: 35083 RVA: 0x00231F64 File Offset: 0x00230164
				// (set) Token: 0x0600890C RID: 35084 RVA: 0x00231F8C File Offset: 0x0023018C
				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: 0x04005B6C RID: 23404
				private static readonly IntPtr NativeFieldInfoPtr_effector;

				// Token: 0x04005B6D RID: 23405
				private static readonly IntPtr NativeFieldInfoPtr_weight;

				// Token: 0x04005B6E RID: 23406
				private static readonly IntPtr NativeFieldInfoPtr_lastValue;

				// Token: 0x04005B6F RID: 23407
				private static readonly IntPtr NativeFieldInfoPtr_current;

				// Token: 0x04005B70 RID: 23408
				private static readonly IntPtr NativeMethodInfoPtr_Apply_Public_Void_IKSolverFullBodyBiped_Vector3_Single_0;

				// Token: 0x04005B71 RID: 23409
				private static readonly IntPtr NativeMethodInfoPtr_CrossFadeStart_Public_Void_0;

				// Token: 0x04005B72 RID: 23410
				private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
			}
		}

		// Token: 0x02000489 RID: 1161
		[Serializable]
		public class HitPointBone : HitReaction.HitPoint
		{
			// Token: 0x0600890D RID: 35085 RVA: 0x00231FB0 File Offset: 0x002301B0
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 621837, XrefRangeEnd = 621841, 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: 0x0600890E RID: 35086 RVA: 0x0023200C File Offset: 0x0023020C
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 621841, XrefRangeEnd = 621843, 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: 0x0600890F RID: 35087 RVA: 0x0023205C File Offset: 0x0023025C
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 621843, XrefRangeEnd = 621860, 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: 0x06008910 RID: 35088 RVA: 0x002320D4 File Offset: 0x002302D4
			[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: 0x06008911 RID: 35089 RVA: 0x00232120 File Offset: 0x00230320
			// 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, 100673763);
				HitReaction.HitPointBone.NativeMethodInfoPtr_CrossFadeStart_Protected_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPointBone>.NativeClassPtr, 100673764);
				HitReaction.HitPointBone.NativeMethodInfoPtr_OnApply_Protected_Virtual_Void_IKSolverFullBodyBiped_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPointBone>.NativeClassPtr, 100673765);
				HitReaction.HitPointBone.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPointBone>.NativeClassPtr, 100673766);
			}

			// Token: 0x06008912 RID: 35090 RVA: 0x00231B9B File Offset: 0x0022FD9B
			public HitPointBone(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002E9E RID: 11934
			// (get) Token: 0x06008913 RID: 35091 RVA: 0x002321D8 File Offset: 0x002303D8
			// (set) Token: 0x06008914 RID: 35092 RVA: 0x0023220C File Offset: 0x0023040C
			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: 0x17002E9F RID: 11935
			// (get) Token: 0x06008915 RID: 35093 RVA: 0x00232234 File Offset: 0x00230434
			// (set) Token: 0x06008916 RID: 35094 RVA: 0x00232268 File Offset: 0x00230468
			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: 0x17002EA0 RID: 11936
			// (get) Token: 0x06008917 RID: 35095 RVA: 0x00232290 File Offset: 0x00230490
			// (set) Token: 0x06008918 RID: 35096 RVA: 0x002322C4 File Offset: 0x002304C4
			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: 0x04005B73 RID: 23411
			private static readonly IntPtr NativeFieldInfoPtr_aroundCenterOfMass;

			// Token: 0x04005B74 RID: 23412
			private static readonly IntPtr NativeFieldInfoPtr_boneLinks;

			// Token: 0x04005B75 RID: 23413
			private static readonly IntPtr NativeFieldInfoPtr_rigidbody;

			// Token: 0x04005B76 RID: 23414
			private static readonly IntPtr NativeMethodInfoPtr_GetLength_Protected_Virtual_Single_0;

			// Token: 0x04005B77 RID: 23415
			private static readonly IntPtr NativeMethodInfoPtr_CrossFadeStart_Protected_Virtual_Void_0;

			// Token: 0x04005B78 RID: 23416
			private static readonly IntPtr NativeMethodInfoPtr_OnApply_Protected_Virtual_Void_IKSolverFullBodyBiped_Single_0;

			// Token: 0x04005B79 RID: 23417
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

			// Token: 0x0200048A RID: 1162
			[Serializable]
			public class BoneLink : Il2CppSystem.Object
			{
				// Token: 0x06008919 RID: 35097 RVA: 0x002322EC File Offset: 0x002304EC
				[CallerCount(1)]
				[CachedScanResults(RefRangeStart = 621832, RefRangeEnd = 621833, XrefRangeStart = 621826, XrefRangeEnd = 621832, 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: 0x0600891A RID: 35098 RVA: 0x0023236C File Offset: 0x0023056C
				[CallerCount(1)]
				[CachedScanResults(RefRangeStart = 621833, RefRangeEnd = 621834, XrefRangeStart = 621833, XrefRangeEnd = 621833, 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: 0x0600891B RID: 35099 RVA: 0x002323B0 File Offset: 0x002305B0
				[CallerCount(0)]
				[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 621834, XrefRangeEnd = 621837, 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: 0x0600891C RID: 35100 RVA: 0x002323FC File Offset: 0x002305FC
				// 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, 100673767);
					HitReaction.HitPointBone.BoneLink.NativeMethodInfoPtr_CrossFadeStart_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPointBone.BoneLink>.NativeClassPtr, 100673768);
					HitReaction.HitPointBone.BoneLink.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReaction.HitPointBone.BoneLink>.NativeClassPtr, 100673769);
				}

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

				// Token: 0x17002EA1 RID: 11937
				// (get) Token: 0x0600891E RID: 35102 RVA: 0x002324B4 File Offset: 0x002306B4
				// (set) Token: 0x0600891F RID: 35103 RVA: 0x002324E8 File Offset: 0x002306E8
				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: 0x17002EA2 RID: 11938
				// (get) Token: 0x06008920 RID: 35104 RVA: 0x00232510 File Offset: 0x00230710
				// (set) Token: 0x06008921 RID: 35105 RVA: 0x00232538 File Offset: 0x00230738
				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: 0x17002EA3 RID: 11939
				// (get) Token: 0x06008922 RID: 35106 RVA: 0x0023255C File Offset: 0x0023075C
				// (set) Token: 0x06008923 RID: 35107 RVA: 0x00232584 File Offset: 0x00230784
				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: 0x17002EA4 RID: 11940
				// (get) Token: 0x06008924 RID: 35108 RVA: 0x002325A8 File Offset: 0x002307A8
				// (set) Token: 0x06008925 RID: 35109 RVA: 0x002325D0 File Offset: 0x002307D0
				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: 0x04005B7A RID: 23418
				private static readonly IntPtr NativeFieldInfoPtr_bone;

				// Token: 0x04005B7B RID: 23419
				private static readonly IntPtr NativeFieldInfoPtr_weight;

				// Token: 0x04005B7C RID: 23420
				private static readonly IntPtr NativeFieldInfoPtr_lastValue;

				// Token: 0x04005B7D RID: 23421
				private static readonly IntPtr NativeFieldInfoPtr_current;

				// Token: 0x04005B7E RID: 23422
				private static readonly IntPtr NativeMethodInfoPtr_Apply_Public_Void_IKSolverFullBodyBiped_Quaternion_Single_0;

				// Token: 0x04005B7F RID: 23423
				private static readonly IntPtr NativeMethodInfoPtr_CrossFadeStart_Public_Void_0;

				// Token: 0x04005B80 RID: 23424
				private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
			}
		}
	}
}