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

namespace RootMotion.FinalIK
{
	// Token: 0x0200048B RID: 1163
	public class HitReactionVRIK : OffsetModifierVRIK
	{
		// Token: 0x06008926 RID: 35110 RVA: 0x002325F4 File Offset: 0x002307F4
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 621988, XrefRangeEnd = 621992, 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), HitReactionVRIK.NativeMethodInfoPtr_OnModifyOffset_Protected_Virtual_Void_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06008927 RID: 35111 RVA: 0x00232644 File Offset: 0x00230844
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 621992, XrefRangeEnd = 622012, 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(HitReactionVRIK.NativeMethodInfoPtr_Hit_Public_Void_Collider_Vector3_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

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

		// Token: 0x06008929 RID: 35113 RVA: 0x00232710 File Offset: 0x00230910
		// Note: this type is marked as 'beforefieldinit'.
		static HitReactionVRIK()
		{
			Il2CppClassPointerStore<HitReactionVRIK>.NativeClassPtr = IL2CPP.GetIl2CppClass("Assembly-CSharp.dll", "RootMotion.FinalIK", "HitReactionVRIK");
			IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<HitReactionVRIK>.NativeClassPtr);
			HitReactionVRIK.NativeFieldInfoPtr_offsetCurves = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReactionVRIK>.NativeClassPtr, "offsetCurves");
			HitReactionVRIK.NativeFieldInfoPtr_positionOffsets = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReactionVRIK>.NativeClassPtr, "positionOffsets");
			HitReactionVRIK.NativeFieldInfoPtr_rotationOffsets = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReactionVRIK>.NativeClassPtr, "rotationOffsets");
			HitReactionVRIK.NativeMethodInfoPtr_OnModifyOffset_Protected_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK>.NativeClassPtr, 100673770);
			HitReactionVRIK.NativeMethodInfoPtr_Hit_Public_Void_Collider_Vector3_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK>.NativeClassPtr, 100673771);
			HitReactionVRIK.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK>.NativeClassPtr, 100673772);
		}

		// Token: 0x0600892A RID: 35114 RVA: 0x002327B8 File Offset: 0x002309B8
		public HitReactionVRIK(IntPtr pointer)
			: base(pointer)
		{
		}

		// Token: 0x17002EA5 RID: 11941
		// (get) Token: 0x0600892B RID: 35115 RVA: 0x002327C4 File Offset: 0x002309C4
		// (set) Token: 0x0600892C RID: 35116 RVA: 0x002327F8 File Offset: 0x002309F8
		public unsafe Il2CppReferenceArray<AnimationCurve> offsetCurves
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.NativeFieldInfoPtr_offsetCurves);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new Il2CppReferenceArray<AnimationCurve>(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.NativeFieldInfoPtr_offsetCurves), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002EA6 RID: 11942
		// (get) Token: 0x0600892D RID: 35117 RVA: 0x00232820 File Offset: 0x00230A20
		// (set) Token: 0x0600892E RID: 35118 RVA: 0x00232854 File Offset: 0x00230A54
		public unsafe Il2CppReferenceArray<HitReactionVRIK.PositionOffset> positionOffsets
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.NativeFieldInfoPtr_positionOffsets);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new Il2CppReferenceArray<HitReactionVRIK.PositionOffset>(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.NativeFieldInfoPtr_positionOffsets), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002EA7 RID: 11943
		// (get) Token: 0x0600892F RID: 35119 RVA: 0x0023287C File Offset: 0x00230A7C
		// (set) Token: 0x06008930 RID: 35120 RVA: 0x002328B0 File Offset: 0x00230AB0
		public unsafe Il2CppReferenceArray<HitReactionVRIK.RotationOffset> rotationOffsets
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.NativeFieldInfoPtr_rotationOffsets);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new Il2CppReferenceArray<HitReactionVRIK.RotationOffset>(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.NativeFieldInfoPtr_rotationOffsets), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x04005B81 RID: 23425
		private static readonly IntPtr NativeFieldInfoPtr_offsetCurves;

		// Token: 0x04005B82 RID: 23426
		private static readonly IntPtr NativeFieldInfoPtr_positionOffsets;

		// Token: 0x04005B83 RID: 23427
		private static readonly IntPtr NativeFieldInfoPtr_rotationOffsets;

		// Token: 0x04005B84 RID: 23428
		private static readonly IntPtr NativeMethodInfoPtr_OnModifyOffset_Protected_Virtual_Void_0;

		// Token: 0x04005B85 RID: 23429
		private static readonly IntPtr NativeMethodInfoPtr_Hit_Public_Void_Collider_Vector3_Vector3_0;

		// Token: 0x04005B86 RID: 23430
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

		// Token: 0x0200048C RID: 1164
		[Serializable]
		public class Offset : Il2CppSystem.Object
		{
			// Token: 0x17002EB2 RID: 11954
			// (get) Token: 0x06008931 RID: 35121 RVA: 0x002328D8 File Offset: 0x00230AD8
			// (set) Token: 0x06008932 RID: 35122 RVA: 0x00232928 File Offset: 0x00230B28
			public unsafe float crossFader
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(HitReactionVRIK.Offset.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(HitReactionVRIK.Offset.NativeMethodInfoPtr_set_crossFader_Private_set_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
						Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					}
				}
			}

			// Token: 0x17002EB3 RID: 11955
			// (get) Token: 0x06008933 RID: 35123 RVA: 0x0023297C File Offset: 0x00230B7C
			// (set) Token: 0x06008934 RID: 35124 RVA: 0x002329CC File Offset: 0x00230BCC
			public unsafe float timer
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(HitReactionVRIK.Offset.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(HitReactionVRIK.Offset.NativeMethodInfoPtr_set_timer_Private_set_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
						Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					}
				}
			}

			// Token: 0x17002EB4 RID: 11956
			// (get) Token: 0x06008935 RID: 35125 RVA: 0x00232A20 File Offset: 0x00230C20
			// (set) Token: 0x06008936 RID: 35126 RVA: 0x00232A70 File Offset: 0x00230C70
			public unsafe Vector3 force
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(HitReactionVRIK.Offset.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(HitReactionVRIK.Offset.NativeMethodInfoPtr_set_force_Private_set_Void_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
						Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					}
				}
			}

			// Token: 0x17002EB5 RID: 11957
			// (get) Token: 0x06008937 RID: 35127 RVA: 0x00232AC4 File Offset: 0x00230CC4
			// (set) Token: 0x06008938 RID: 35128 RVA: 0x00232B14 File Offset: 0x00230D14
			public unsafe Vector3 point
			{
				[CallerCount(0)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(HitReactionVRIK.Offset.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(HitReactionVRIK.Offset.NativeMethodInfoPtr_set_point_Private_set_Void_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
						Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					}
				}
			}

			// Token: 0x06008939 RID: 35129 RVA: 0x00232B68 File Offset: 0x00230D68
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 621897, RefRangeEnd = 621899, XrefRangeStart = 621889, XrefRangeEnd = 621897, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void Hit(Vector3 force, Il2CppReferenceArray<AnimationCurve> curves, Vector3 point)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref force;
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(curves);
				ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref point;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(HitReactionVRIK.Offset.NativeMethodInfoPtr_Hit_Public_Void_Vector3_Il2CppReferenceArray_1_AnimationCurve_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x0600893A RID: 35130 RVA: 0x00232BE8 File Offset: 0x00230DE8
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 621904, RefRangeEnd = 621906, XrefRangeStart = 621899, XrefRangeEnd = 621904, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void Apply(VRIK ik, Il2CppReferenceArray<AnimationCurve> curves, float weight)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(ik);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(curves);
				ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref weight;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(HitReactionVRIK.Offset.NativeMethodInfoPtr_Apply_Public_Void_VRIK_Il2CppReferenceArray_1_AnimationCurve_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x0600893B RID: 35131 RVA: 0x00232C6C File Offset: 0x00230E6C
			[CallerCount(0)]
			public unsafe virtual float GetLength(Il2CppReferenceArray<AnimationCurve> curves)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				checked
				{
					IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(curves);
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), HitReactionVRIK.Offset.NativeMethodInfoPtr_GetLength_Protected_Abstract_Virtual_New_Single_Il2CppReferenceArray_1_AnimationCurve_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
			}

			// Token: 0x0600893C RID: 35132 RVA: 0x00232CE0 File Offset: 0x00230EE0
			[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), HitReactionVRIK.Offset.NativeMethodInfoPtr_CrossFadeStart_Protected_Abstract_Virtual_New_Void_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x0600893D RID: 35133 RVA: 0x00232D30 File Offset: 0x00230F30
			[CallerCount(0)]
			public unsafe virtual void OnApply(VRIK ik, Il2CppReferenceArray<AnimationCurve> curves, float weight)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(ik);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(curves);
				ptr[checked(unchecked((UIntPtr)2) * (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), HitReactionVRIK.Offset.NativeMethodInfoPtr_OnApply_Protected_Abstract_Virtual_New_Void_VRIK_Il2CppReferenceArray_1_AnimationCurve_Single_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

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

			// Token: 0x0600893F RID: 35135 RVA: 0x00232E0C File Offset: 0x0023100C
			// Note: this type is marked as 'beforefieldinit'.
			static Offset()
			{
				Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<HitReactionVRIK>.NativeClassPtr, "Offset");
				IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr);
				HitReactionVRIK.Offset.NativeFieldInfoPtr_name = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, "name");
				HitReactionVRIK.Offset.NativeFieldInfoPtr_collider = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, "collider");
				HitReactionVRIK.Offset.NativeFieldInfoPtr_crossFadeTime = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, "crossFadeTime");
				HitReactionVRIK.Offset.NativeFieldInfoPtr__crossFader_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, "<crossFader>k__BackingField");
				HitReactionVRIK.Offset.NativeFieldInfoPtr__timer_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, "<timer>k__BackingField");
				HitReactionVRIK.Offset.NativeFieldInfoPtr__force_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, "<force>k__BackingField");
				HitReactionVRIK.Offset.NativeFieldInfoPtr__point_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, "<point>k__BackingField");
				HitReactionVRIK.Offset.NativeFieldInfoPtr_length = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, "length");
				HitReactionVRIK.Offset.NativeFieldInfoPtr_crossFadeSpeed = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, "crossFadeSpeed");
				HitReactionVRIK.Offset.NativeFieldInfoPtr_lastTime = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, "lastTime");
				HitReactionVRIK.Offset.NativeMethodInfoPtr_get_crossFader_Protected_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, 100673773);
				HitReactionVRIK.Offset.NativeMethodInfoPtr_set_crossFader_Private_set_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, 100673774);
				HitReactionVRIK.Offset.NativeMethodInfoPtr_get_timer_Protected_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, 100673775);
				HitReactionVRIK.Offset.NativeMethodInfoPtr_set_timer_Private_set_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, 100673776);
				HitReactionVRIK.Offset.NativeMethodInfoPtr_get_force_Protected_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, 100673777);
				HitReactionVRIK.Offset.NativeMethodInfoPtr_set_force_Private_set_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, 100673778);
				HitReactionVRIK.Offset.NativeMethodInfoPtr_get_point_Protected_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, 100673779);
				HitReactionVRIK.Offset.NativeMethodInfoPtr_set_point_Private_set_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, 100673780);
				HitReactionVRIK.Offset.NativeMethodInfoPtr_Hit_Public_Void_Vector3_Il2CppReferenceArray_1_AnimationCurve_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, 100673781);
				HitReactionVRIK.Offset.NativeMethodInfoPtr_Apply_Public_Void_VRIK_Il2CppReferenceArray_1_AnimationCurve_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, 100673782);
				HitReactionVRIK.Offset.NativeMethodInfoPtr_GetLength_Protected_Abstract_Virtual_New_Single_Il2CppReferenceArray_1_AnimationCurve_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, 100673783);
				HitReactionVRIK.Offset.NativeMethodInfoPtr_CrossFadeStart_Protected_Abstract_Virtual_New_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, 100673784);
				HitReactionVRIK.Offset.NativeMethodInfoPtr_OnApply_Protected_Abstract_Virtual_New_Void_VRIK_Il2CppReferenceArray_1_AnimationCurve_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, 100673785);
				HitReactionVRIK.Offset.NativeMethodInfoPtr__ctor_Protected_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, 100673786);
			}

			// Token: 0x06008940 RID: 35136 RVA: 0x0000A74C File Offset: 0x0000894C
			public Offset(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002EA8 RID: 11944
			// (get) Token: 0x06008941 RID: 35137 RVA: 0x00233018 File Offset: 0x00231218
			// (set) Token: 0x06008942 RID: 35138 RVA: 0x00233041 File Offset: 0x00231241
			public unsafe string name
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.Offset.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(HitReactionVRIK.Offset.NativeFieldInfoPtr_name), IL2CPP.ManagedStringToIl2Cpp(value));
				}
			}

			// Token: 0x17002EA9 RID: 11945
			// (get) Token: 0x06008943 RID: 35139 RVA: 0x00233068 File Offset: 0x00231268
			// (set) Token: 0x06008944 RID: 35140 RVA: 0x0023309C File Offset: 0x0023129C
			public unsafe Collider collider
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.Offset.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(HitReactionVRIK.Offset.NativeFieldInfoPtr_collider), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x17002EAA RID: 11946
			// (get) Token: 0x06008945 RID: 35141 RVA: 0x002330C4 File Offset: 0x002312C4
			// (set) Token: 0x06008946 RID: 35142 RVA: 0x002330EC File Offset: 0x002312EC
			public unsafe float crossFadeTime
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.Offset.NativeFieldInfoPtr_crossFadeTime);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.Offset.NativeFieldInfoPtr_crossFadeTime)) = value;
				}
			}

			// Token: 0x17002EAB RID: 11947
			// (get) Token: 0x06008947 RID: 35143 RVA: 0x00233110 File Offset: 0x00231310
			// (set) Token: 0x06008948 RID: 35144 RVA: 0x00233138 File Offset: 0x00231338
			public unsafe float _crossFader_k__BackingField
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.Offset.NativeFieldInfoPtr__crossFader_k__BackingField);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.Offset.NativeFieldInfoPtr__crossFader_k__BackingField)) = value;
				}
			}

			// Token: 0x17002EAC RID: 11948
			// (get) Token: 0x06008949 RID: 35145 RVA: 0x0023315C File Offset: 0x0023135C
			// (set) Token: 0x0600894A RID: 35146 RVA: 0x00233184 File Offset: 0x00231384
			public unsafe float _timer_k__BackingField
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.Offset.NativeFieldInfoPtr__timer_k__BackingField);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.Offset.NativeFieldInfoPtr__timer_k__BackingField)) = value;
				}
			}

			// Token: 0x17002EAD RID: 11949
			// (get) Token: 0x0600894B RID: 35147 RVA: 0x002331A8 File Offset: 0x002313A8
			// (set) Token: 0x0600894C RID: 35148 RVA: 0x002331D0 File Offset: 0x002313D0
			public unsafe Vector3 _force_k__BackingField
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.Offset.NativeFieldInfoPtr__force_k__BackingField);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.Offset.NativeFieldInfoPtr__force_k__BackingField)) = value;
				}
			}

			// Token: 0x17002EAE RID: 11950
			// (get) Token: 0x0600894D RID: 35149 RVA: 0x002331F4 File Offset: 0x002313F4
			// (set) Token: 0x0600894E RID: 35150 RVA: 0x0023321C File Offset: 0x0023141C
			public unsafe Vector3 _point_k__BackingField
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.Offset.NativeFieldInfoPtr__point_k__BackingField);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.Offset.NativeFieldInfoPtr__point_k__BackingField)) = value;
				}
			}

			// Token: 0x17002EAF RID: 11951
			// (get) Token: 0x0600894F RID: 35151 RVA: 0x00233240 File Offset: 0x00231440
			// (set) Token: 0x06008950 RID: 35152 RVA: 0x00233268 File Offset: 0x00231468
			public unsafe float length
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.Offset.NativeFieldInfoPtr_length);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.Offset.NativeFieldInfoPtr_length)) = value;
				}
			}

			// Token: 0x17002EB0 RID: 11952
			// (get) Token: 0x06008951 RID: 35153 RVA: 0x0023328C File Offset: 0x0023148C
			// (set) Token: 0x06008952 RID: 35154 RVA: 0x002332B4 File Offset: 0x002314B4
			public unsafe float crossFadeSpeed
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.Offset.NativeFieldInfoPtr_crossFadeSpeed);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.Offset.NativeFieldInfoPtr_crossFadeSpeed)) = value;
				}
			}

			// Token: 0x17002EB1 RID: 11953
			// (get) Token: 0x06008953 RID: 35155 RVA: 0x002332D8 File Offset: 0x002314D8
			// (set) Token: 0x06008954 RID: 35156 RVA: 0x00233300 File Offset: 0x00231500
			public unsafe float lastTime
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.Offset.NativeFieldInfoPtr_lastTime);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.Offset.NativeFieldInfoPtr_lastTime)) = value;
				}
			}

			// Token: 0x04005B87 RID: 23431
			private static readonly IntPtr NativeFieldInfoPtr_name;

			// Token: 0x04005B88 RID: 23432
			private static readonly IntPtr NativeFieldInfoPtr_collider;

			// Token: 0x04005B89 RID: 23433
			private static readonly IntPtr NativeFieldInfoPtr_crossFadeTime;

			// Token: 0x04005B8A RID: 23434
			private static readonly IntPtr NativeFieldInfoPtr__crossFader_k__BackingField;

			// Token: 0x04005B8B RID: 23435
			private static readonly IntPtr NativeFieldInfoPtr__timer_k__BackingField;

			// Token: 0x04005B8C RID: 23436
			private static readonly IntPtr NativeFieldInfoPtr__force_k__BackingField;

			// Token: 0x04005B8D RID: 23437
			private static readonly IntPtr NativeFieldInfoPtr__point_k__BackingField;

			// Token: 0x04005B8E RID: 23438
			private static readonly IntPtr NativeFieldInfoPtr_length;

			// Token: 0x04005B8F RID: 23439
			private static readonly IntPtr NativeFieldInfoPtr_crossFadeSpeed;

			// Token: 0x04005B90 RID: 23440
			private static readonly IntPtr NativeFieldInfoPtr_lastTime;

			// Token: 0x04005B91 RID: 23441
			private static readonly IntPtr NativeMethodInfoPtr_get_crossFader_Protected_get_Single_0;

			// Token: 0x04005B92 RID: 23442
			private static readonly IntPtr NativeMethodInfoPtr_set_crossFader_Private_set_Void_Single_0;

			// Token: 0x04005B93 RID: 23443
			private static readonly IntPtr NativeMethodInfoPtr_get_timer_Protected_get_Single_0;

			// Token: 0x04005B94 RID: 23444
			private static readonly IntPtr NativeMethodInfoPtr_set_timer_Private_set_Void_Single_0;

			// Token: 0x04005B95 RID: 23445
			private static readonly IntPtr NativeMethodInfoPtr_get_force_Protected_get_Vector3_0;

			// Token: 0x04005B96 RID: 23446
			private static readonly IntPtr NativeMethodInfoPtr_set_force_Private_set_Void_Vector3_0;

			// Token: 0x04005B97 RID: 23447
			private static readonly IntPtr NativeMethodInfoPtr_get_point_Protected_get_Vector3_0;

			// Token: 0x04005B98 RID: 23448
			private static readonly IntPtr NativeMethodInfoPtr_set_point_Private_set_Void_Vector3_0;

			// Token: 0x04005B99 RID: 23449
			private static readonly IntPtr NativeMethodInfoPtr_Hit_Public_Void_Vector3_Il2CppReferenceArray_1_AnimationCurve_Vector3_0;

			// Token: 0x04005B9A RID: 23450
			private static readonly IntPtr NativeMethodInfoPtr_Apply_Public_Void_VRIK_Il2CppReferenceArray_1_AnimationCurve_Single_0;

			// Token: 0x04005B9B RID: 23451
			private static readonly IntPtr NativeMethodInfoPtr_GetLength_Protected_Abstract_Virtual_New_Single_Il2CppReferenceArray_1_AnimationCurve_0;

			// Token: 0x04005B9C RID: 23452
			private static readonly IntPtr NativeMethodInfoPtr_CrossFadeStart_Protected_Abstract_Virtual_New_Void_0;

			// Token: 0x04005B9D RID: 23453
			private static readonly IntPtr NativeMethodInfoPtr_OnApply_Protected_Abstract_Virtual_New_Void_VRIK_Il2CppReferenceArray_1_AnimationCurve_Single_0;

			// Token: 0x04005B9E RID: 23454
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Protected_Void_0;
		}

		// Token: 0x0200048D RID: 1165
		[Serializable]
		public class PositionOffset : HitReactionVRIK.Offset
		{
			// Token: 0x06008955 RID: 35157 RVA: 0x00233324 File Offset: 0x00231524
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 621909, XrefRangeEnd = 621936, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe override float GetLength(Il2CppReferenceArray<AnimationCurve> curves)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				checked
				{
					IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(curves);
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), HitReactionVRIK.PositionOffset.NativeMethodInfoPtr_GetLength_Protected_Virtual_Single_Il2CppReferenceArray_1_AnimationCurve_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
			}

			// Token: 0x06008956 RID: 35158 RVA: 0x00233398 File Offset: 0x00231598
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 621936, XrefRangeEnd = 621938, 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), HitReactionVRIK.PositionOffset.NativeMethodInfoPtr_CrossFadeStart_Protected_Virtual_Void_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008957 RID: 35159 RVA: 0x002333E8 File Offset: 0x002315E8
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 621938, XrefRangeEnd = 621945, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe override void OnApply(VRIK ik, Il2CppReferenceArray<AnimationCurve> curves, float weight)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(ik);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(curves);
				ptr[checked(unchecked((UIntPtr)2) * (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), HitReactionVRIK.PositionOffset.NativeMethodInfoPtr_OnApply_Protected_Virtual_Void_VRIK_Il2CppReferenceArray_1_AnimationCurve_Single_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008958 RID: 35160 RVA: 0x00233478 File Offset: 0x00231678
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 621945, XrefRangeEnd = 621946, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe PositionOffset()
				: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<HitReactionVRIK.PositionOffset>.NativeClassPtr))
			{
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(HitReactionVRIK.PositionOffset.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008959 RID: 35161 RVA: 0x002334C4 File Offset: 0x002316C4
			// Note: this type is marked as 'beforefieldinit'.
			static PositionOffset()
			{
				Il2CppClassPointerStore<HitReactionVRIK.PositionOffset>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<HitReactionVRIK>.NativeClassPtr, "PositionOffset");
				IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<HitReactionVRIK.PositionOffset>.NativeClassPtr);
				HitReactionVRIK.PositionOffset.NativeFieldInfoPtr_forceDirCurveIndex = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReactionVRIK.PositionOffset>.NativeClassPtr, "forceDirCurveIndex");
				HitReactionVRIK.PositionOffset.NativeFieldInfoPtr_upDirCurveIndex = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReactionVRIK.PositionOffset>.NativeClassPtr, "upDirCurveIndex");
				HitReactionVRIK.PositionOffset.NativeFieldInfoPtr_offsetLinks = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReactionVRIK.PositionOffset>.NativeClassPtr, "offsetLinks");
				HitReactionVRIK.PositionOffset.NativeMethodInfoPtr_GetLength_Protected_Virtual_Single_Il2CppReferenceArray_1_AnimationCurve_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.PositionOffset>.NativeClassPtr, 100673787);
				HitReactionVRIK.PositionOffset.NativeMethodInfoPtr_CrossFadeStart_Protected_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.PositionOffset>.NativeClassPtr, 100673788);
				HitReactionVRIK.PositionOffset.NativeMethodInfoPtr_OnApply_Protected_Virtual_Void_VRIK_Il2CppReferenceArray_1_AnimationCurve_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.PositionOffset>.NativeClassPtr, 100673789);
				HitReactionVRIK.PositionOffset.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.PositionOffset>.NativeClassPtr, 100673790);
			}

			// Token: 0x0600895A RID: 35162 RVA: 0x0023357B File Offset: 0x0023177B
			public PositionOffset(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002EB6 RID: 11958
			// (get) Token: 0x0600895B RID: 35163 RVA: 0x00233584 File Offset: 0x00231784
			// (set) Token: 0x0600895C RID: 35164 RVA: 0x002335AC File Offset: 0x002317AC
			public unsafe int forceDirCurveIndex
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.PositionOffset.NativeFieldInfoPtr_forceDirCurveIndex);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.PositionOffset.NativeFieldInfoPtr_forceDirCurveIndex)) = value;
				}
			}

			// Token: 0x17002EB7 RID: 11959
			// (get) Token: 0x0600895D RID: 35165 RVA: 0x002335D0 File Offset: 0x002317D0
			// (set) Token: 0x0600895E RID: 35166 RVA: 0x002335F8 File Offset: 0x002317F8
			public unsafe int upDirCurveIndex
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.PositionOffset.NativeFieldInfoPtr_upDirCurveIndex);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.PositionOffset.NativeFieldInfoPtr_upDirCurveIndex)) = value;
				}
			}

			// Token: 0x17002EB8 RID: 11960
			// (get) Token: 0x0600895F RID: 35167 RVA: 0x0023361C File Offset: 0x0023181C
			// (set) Token: 0x06008960 RID: 35168 RVA: 0x00233650 File Offset: 0x00231850
			public unsafe Il2CppReferenceArray<HitReactionVRIK.PositionOffset.PositionOffsetLink> offsetLinks
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.PositionOffset.NativeFieldInfoPtr_offsetLinks);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new Il2CppReferenceArray<HitReactionVRIK.PositionOffset.PositionOffsetLink>(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.PositionOffset.NativeFieldInfoPtr_offsetLinks), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x04005B9F RID: 23455
			private static readonly IntPtr NativeFieldInfoPtr_forceDirCurveIndex;

			// Token: 0x04005BA0 RID: 23456
			private static readonly IntPtr NativeFieldInfoPtr_upDirCurveIndex;

			// Token: 0x04005BA1 RID: 23457
			private static readonly IntPtr NativeFieldInfoPtr_offsetLinks;

			// Token: 0x04005BA2 RID: 23458
			private static readonly IntPtr NativeMethodInfoPtr_GetLength_Protected_Virtual_Single_Il2CppReferenceArray_1_AnimationCurve_0;

			// Token: 0x04005BA3 RID: 23459
			private static readonly IntPtr NativeMethodInfoPtr_CrossFadeStart_Protected_Virtual_Void_0;

			// Token: 0x04005BA4 RID: 23460
			private static readonly IntPtr NativeMethodInfoPtr_OnApply_Protected_Virtual_Void_VRIK_Il2CppReferenceArray_1_AnimationCurve_Single_0;

			// Token: 0x04005BA5 RID: 23461
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

			// Token: 0x0200048E RID: 1166
			[Serializable]
			public class PositionOffsetLink : Il2CppSystem.Object
			{
				// Token: 0x06008961 RID: 35169 RVA: 0x00233678 File Offset: 0x00231878
				[CallerCount(1)]
				[CachedScanResults(RefRangeStart = 621908, RefRangeEnd = 621909, XrefRangeStart = 621906, XrefRangeEnd = 621908, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
				public unsafe void Apply(VRIK ik, Vector3 offset, float crossFader)
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr;
					checked
					{
						ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
						*ptr = IL2CPP.Il2CppObjectBaseToPtr(ik);
					}
					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(HitReactionVRIK.PositionOffset.PositionOffsetLink.NativeMethodInfoPtr_Apply_Public_Void_VRIK_Vector3_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				}

				// Token: 0x06008962 RID: 35170 RVA: 0x002336F8 File Offset: 0x002318F8
				[CallerCount(2)]
				[CachedScanResults(RefRangeStart = 621801, RefRangeEnd = 621803, XrefRangeStart = 621801, XrefRangeEnd = 621803, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
				public unsafe void CrossFadeStart()
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(HitReactionVRIK.PositionOffset.PositionOffsetLink.NativeMethodInfoPtr_CrossFadeStart_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				}

				// Token: 0x06008963 RID: 35171 RVA: 0x0023373C File Offset: 0x0023193C
				[CallerCount(1659)]
				[CachedScanResults(RefRangeStart = 7639, RefRangeEnd = 9298, XrefRangeStart = 7639, XrefRangeEnd = 9298, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
				public unsafe PositionOffsetLink()
					: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<HitReactionVRIK.PositionOffset.PositionOffsetLink>.NativeClassPtr))
				{
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(HitReactionVRIK.PositionOffset.PositionOffsetLink.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				}

				// Token: 0x06008964 RID: 35172 RVA: 0x00233788 File Offset: 0x00231988
				// Note: this type is marked as 'beforefieldinit'.
				static PositionOffsetLink()
				{
					Il2CppClassPointerStore<HitReactionVRIK.PositionOffset.PositionOffsetLink>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<HitReactionVRIK.PositionOffset>.NativeClassPtr, "PositionOffsetLink");
					IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<HitReactionVRIK.PositionOffset.PositionOffsetLink>.NativeClassPtr);
					HitReactionVRIK.PositionOffset.PositionOffsetLink.NativeFieldInfoPtr_positionOffset = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReactionVRIK.PositionOffset.PositionOffsetLink>.NativeClassPtr, "positionOffset");
					HitReactionVRIK.PositionOffset.PositionOffsetLink.NativeFieldInfoPtr_weight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReactionVRIK.PositionOffset.PositionOffsetLink>.NativeClassPtr, "weight");
					HitReactionVRIK.PositionOffset.PositionOffsetLink.NativeFieldInfoPtr_lastValue = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReactionVRIK.PositionOffset.PositionOffsetLink>.NativeClassPtr, "lastValue");
					HitReactionVRIK.PositionOffset.PositionOffsetLink.NativeFieldInfoPtr_current = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReactionVRIK.PositionOffset.PositionOffsetLink>.NativeClassPtr, "current");
					HitReactionVRIK.PositionOffset.PositionOffsetLink.NativeMethodInfoPtr_Apply_Public_Void_VRIK_Vector3_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.PositionOffset.PositionOffsetLink>.NativeClassPtr, 100673791);
					HitReactionVRIK.PositionOffset.PositionOffsetLink.NativeMethodInfoPtr_CrossFadeStart_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.PositionOffset.PositionOffsetLink>.NativeClassPtr, 100673792);
					HitReactionVRIK.PositionOffset.PositionOffsetLink.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.PositionOffset.PositionOffsetLink>.NativeClassPtr, 100673793);
				}

				// Token: 0x06008965 RID: 35173 RVA: 0x0000A74C File Offset: 0x0000894C
				public PositionOffsetLink(IntPtr pointer)
					: base(pointer)
				{
				}

				// Token: 0x17002EB9 RID: 11961
				// (get) Token: 0x06008966 RID: 35174 RVA: 0x00233840 File Offset: 0x00231A40
				// (set) Token: 0x06008967 RID: 35175 RVA: 0x00233868 File Offset: 0x00231A68
				public unsafe IKSolverVR.PositionOffset positionOffset
				{
					get
					{
						IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.PositionOffset.PositionOffsetLink.NativeFieldInfoPtr_positionOffset);
						return *intPtr;
					}
					set
					{
						*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.PositionOffset.PositionOffsetLink.NativeFieldInfoPtr_positionOffset)) = value;
					}
				}

				// Token: 0x17002EBA RID: 11962
				// (get) Token: 0x06008968 RID: 35176 RVA: 0x0023388C File Offset: 0x00231A8C
				// (set) Token: 0x06008969 RID: 35177 RVA: 0x002338B4 File Offset: 0x00231AB4
				public unsafe float weight
				{
					get
					{
						IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.PositionOffset.PositionOffsetLink.NativeFieldInfoPtr_weight);
						return *intPtr;
					}
					set
					{
						*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.PositionOffset.PositionOffsetLink.NativeFieldInfoPtr_weight)) = value;
					}
				}

				// Token: 0x17002EBB RID: 11963
				// (get) Token: 0x0600896A RID: 35178 RVA: 0x002338D8 File Offset: 0x00231AD8
				// (set) Token: 0x0600896B RID: 35179 RVA: 0x00233900 File Offset: 0x00231B00
				public unsafe Vector3 lastValue
				{
					get
					{
						IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.PositionOffset.PositionOffsetLink.NativeFieldInfoPtr_lastValue);
						return *intPtr;
					}
					set
					{
						*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.PositionOffset.PositionOffsetLink.NativeFieldInfoPtr_lastValue)) = value;
					}
				}

				// Token: 0x17002EBC RID: 11964
				// (get) Token: 0x0600896C RID: 35180 RVA: 0x00233924 File Offset: 0x00231B24
				// (set) Token: 0x0600896D RID: 35181 RVA: 0x0023394C File Offset: 0x00231B4C
				public unsafe Vector3 current
				{
					get
					{
						IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.PositionOffset.PositionOffsetLink.NativeFieldInfoPtr_current);
						return *intPtr;
					}
					set
					{
						*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.PositionOffset.PositionOffsetLink.NativeFieldInfoPtr_current)) = value;
					}
				}

				// Token: 0x04005BA6 RID: 23462
				private static readonly IntPtr NativeFieldInfoPtr_positionOffset;

				// Token: 0x04005BA7 RID: 23463
				private static readonly IntPtr NativeFieldInfoPtr_weight;

				// Token: 0x04005BA8 RID: 23464
				private static readonly IntPtr NativeFieldInfoPtr_lastValue;

				// Token: 0x04005BA9 RID: 23465
				private static readonly IntPtr NativeFieldInfoPtr_current;

				// Token: 0x04005BAA RID: 23466
				private static readonly IntPtr NativeMethodInfoPtr_Apply_Public_Void_VRIK_Vector3_Single_0;

				// Token: 0x04005BAB RID: 23467
				private static readonly IntPtr NativeMethodInfoPtr_CrossFadeStart_Public_Void_0;

				// Token: 0x04005BAC RID: 23468
				private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
			}
		}

		// Token: 0x0200048F RID: 1167
		[Serializable]
		public class RotationOffset : HitReactionVRIK.Offset
		{
			// Token: 0x0600896E RID: 35182 RVA: 0x00233970 File Offset: 0x00231B70
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 621955, XrefRangeEnd = 621959, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe override float GetLength(Il2CppReferenceArray<AnimationCurve> curves)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				checked
				{
					IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(curves);
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), HitReactionVRIK.RotationOffset.NativeMethodInfoPtr_GetLength_Protected_Virtual_Single_Il2CppReferenceArray_1_AnimationCurve_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					return *IL2CPP.il2cpp_object_unbox(intPtr);
				}
			}

			// Token: 0x0600896F RID: 35183 RVA: 0x002339E4 File Offset: 0x00231BE4
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 621959, XrefRangeEnd = 621961, 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), HitReactionVRIK.RotationOffset.NativeMethodInfoPtr_CrossFadeStart_Protected_Virtual_Void_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008970 RID: 35184 RVA: 0x00233A34 File Offset: 0x00231C34
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 621961, XrefRangeEnd = 621988, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe override void OnApply(VRIK ik, Il2CppReferenceArray<AnimationCurve> curves, float weight)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(ik);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(curves);
				ptr[checked(unchecked((UIntPtr)2) * (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), HitReactionVRIK.RotationOffset.NativeMethodInfoPtr_OnApply_Protected_Virtual_Void_VRIK_Il2CppReferenceArray_1_AnimationCurve_Single_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

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

			// Token: 0x06008972 RID: 35186 RVA: 0x00233B10 File Offset: 0x00231D10
			// Note: this type is marked as 'beforefieldinit'.
			static RotationOffset()
			{
				Il2CppClassPointerStore<HitReactionVRIK.RotationOffset>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<HitReactionVRIK>.NativeClassPtr, "RotationOffset");
				IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<HitReactionVRIK.RotationOffset>.NativeClassPtr);
				HitReactionVRIK.RotationOffset.NativeFieldInfoPtr_curveIndex = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReactionVRIK.RotationOffset>.NativeClassPtr, "curveIndex");
				HitReactionVRIK.RotationOffset.NativeFieldInfoPtr_offsetLinks = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReactionVRIK.RotationOffset>.NativeClassPtr, "offsetLinks");
				HitReactionVRIK.RotationOffset.NativeFieldInfoPtr_rigidbody = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReactionVRIK.RotationOffset>.NativeClassPtr, "rigidbody");
				HitReactionVRIK.RotationOffset.NativeMethodInfoPtr_GetLength_Protected_Virtual_Single_Il2CppReferenceArray_1_AnimationCurve_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.RotationOffset>.NativeClassPtr, 100673794);
				HitReactionVRIK.RotationOffset.NativeMethodInfoPtr_CrossFadeStart_Protected_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.RotationOffset>.NativeClassPtr, 100673795);
				HitReactionVRIK.RotationOffset.NativeMethodInfoPtr_OnApply_Protected_Virtual_Void_VRIK_Il2CppReferenceArray_1_AnimationCurve_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.RotationOffset>.NativeClassPtr, 100673796);
				HitReactionVRIK.RotationOffset.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.RotationOffset>.NativeClassPtr, 100673797);
			}

			// Token: 0x06008973 RID: 35187 RVA: 0x0023357B File Offset: 0x0023177B
			public RotationOffset(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002EBD RID: 11965
			// (get) Token: 0x06008974 RID: 35188 RVA: 0x00233BC8 File Offset: 0x00231DC8
			// (set) Token: 0x06008975 RID: 35189 RVA: 0x00233BF0 File Offset: 0x00231DF0
			public unsafe int curveIndex
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.RotationOffset.NativeFieldInfoPtr_curveIndex);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.RotationOffset.NativeFieldInfoPtr_curveIndex)) = value;
				}
			}

			// Token: 0x17002EBE RID: 11966
			// (get) Token: 0x06008976 RID: 35190 RVA: 0x00233C14 File Offset: 0x00231E14
			// (set) Token: 0x06008977 RID: 35191 RVA: 0x00233C48 File Offset: 0x00231E48
			public unsafe Il2CppReferenceArray<HitReactionVRIK.RotationOffset.RotationOffsetLink> offsetLinks
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.RotationOffset.NativeFieldInfoPtr_offsetLinks);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new Il2CppReferenceArray<HitReactionVRIK.RotationOffset.RotationOffsetLink>(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.RotationOffset.NativeFieldInfoPtr_offsetLinks), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x17002EBF RID: 11967
			// (get) Token: 0x06008978 RID: 35192 RVA: 0x00233C70 File Offset: 0x00231E70
			// (set) Token: 0x06008979 RID: 35193 RVA: 0x00233CA4 File Offset: 0x00231EA4
			public unsafe Rigidbody rigidbody
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.RotationOffset.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(HitReactionVRIK.RotationOffset.NativeFieldInfoPtr_rigidbody), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x04005BAD RID: 23469
			private static readonly IntPtr NativeFieldInfoPtr_curveIndex;

			// Token: 0x04005BAE RID: 23470
			private static readonly IntPtr NativeFieldInfoPtr_offsetLinks;

			// Token: 0x04005BAF RID: 23471
			private static readonly IntPtr NativeFieldInfoPtr_rigidbody;

			// Token: 0x04005BB0 RID: 23472
			private static readonly IntPtr NativeMethodInfoPtr_GetLength_Protected_Virtual_Single_Il2CppReferenceArray_1_AnimationCurve_0;

			// Token: 0x04005BB1 RID: 23473
			private static readonly IntPtr NativeMethodInfoPtr_CrossFadeStart_Protected_Virtual_Void_0;

			// Token: 0x04005BB2 RID: 23474
			private static readonly IntPtr NativeMethodInfoPtr_OnApply_Protected_Virtual_Void_VRIK_Il2CppReferenceArray_1_AnimationCurve_Single_0;

			// Token: 0x04005BB3 RID: 23475
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

			// Token: 0x02000490 RID: 1168
			[Serializable]
			public class RotationOffsetLink : Il2CppSystem.Object
			{
				// Token: 0x0600897A RID: 35194 RVA: 0x00233CCC File Offset: 0x00231ECC
				[CallerCount(1)]
				[CachedScanResults(RefRangeStart = 621950, RefRangeEnd = 621951, XrefRangeStart = 621946, XrefRangeEnd = 621950, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
				public unsafe void Apply(VRIK ik, Quaternion offset, float crossFader)
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr;
					checked
					{
						ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
						*ptr = IL2CPP.Il2CppObjectBaseToPtr(ik);
					}
					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(HitReactionVRIK.RotationOffset.RotationOffsetLink.NativeMethodInfoPtr_Apply_Public_Void_VRIK_Quaternion_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				}

				// Token: 0x0600897B RID: 35195 RVA: 0x00233D4C File Offset: 0x00231F4C
				[CallerCount(1)]
				[CachedScanResults(RefRangeStart = 621951, RefRangeEnd = 621952, XrefRangeStart = 621951, XrefRangeEnd = 621951, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
				public unsafe void CrossFadeStart()
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(HitReactionVRIK.RotationOffset.RotationOffsetLink.NativeMethodInfoPtr_CrossFadeStart_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				}

				// Token: 0x0600897C RID: 35196 RVA: 0x00233D90 File Offset: 0x00231F90
				[CallerCount(0)]
				[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 621952, XrefRangeEnd = 621955, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
				public unsafe RotationOffsetLink()
					: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<HitReactionVRIK.RotationOffset.RotationOffsetLink>.NativeClassPtr))
				{
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(HitReactionVRIK.RotationOffset.RotationOffsetLink.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				}

				// Token: 0x0600897D RID: 35197 RVA: 0x00233DDC File Offset: 0x00231FDC
				// Note: this type is marked as 'beforefieldinit'.
				static RotationOffsetLink()
				{
					Il2CppClassPointerStore<HitReactionVRIK.RotationOffset.RotationOffsetLink>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<HitReactionVRIK.RotationOffset>.NativeClassPtr, "RotationOffsetLink");
					IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<HitReactionVRIK.RotationOffset.RotationOffsetLink>.NativeClassPtr);
					HitReactionVRIK.RotationOffset.RotationOffsetLink.NativeFieldInfoPtr_rotationOffset = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReactionVRIK.RotationOffset.RotationOffsetLink>.NativeClassPtr, "rotationOffset");
					HitReactionVRIK.RotationOffset.RotationOffsetLink.NativeFieldInfoPtr_weight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReactionVRIK.RotationOffset.RotationOffsetLink>.NativeClassPtr, "weight");
					HitReactionVRIK.RotationOffset.RotationOffsetLink.NativeFieldInfoPtr_lastValue = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReactionVRIK.RotationOffset.RotationOffsetLink>.NativeClassPtr, "lastValue");
					HitReactionVRIK.RotationOffset.RotationOffsetLink.NativeFieldInfoPtr_current = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<HitReactionVRIK.RotationOffset.RotationOffsetLink>.NativeClassPtr, "current");
					HitReactionVRIK.RotationOffset.RotationOffsetLink.NativeMethodInfoPtr_Apply_Public_Void_VRIK_Quaternion_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.RotationOffset.RotationOffsetLink>.NativeClassPtr, 100673798);
					HitReactionVRIK.RotationOffset.RotationOffsetLink.NativeMethodInfoPtr_CrossFadeStart_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.RotationOffset.RotationOffsetLink>.NativeClassPtr, 100673799);
					HitReactionVRIK.RotationOffset.RotationOffsetLink.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.RotationOffset.RotationOffsetLink>.NativeClassPtr, 100673800);
				}

				// Token: 0x0600897E RID: 35198 RVA: 0x0000A74C File Offset: 0x0000894C
				public RotationOffsetLink(IntPtr pointer)
					: base(pointer)
				{
				}

				// Token: 0x17002EC0 RID: 11968
				// (get) Token: 0x0600897F RID: 35199 RVA: 0x00233E94 File Offset: 0x00232094
				// (set) Token: 0x06008980 RID: 35200 RVA: 0x00233EBC File Offset: 0x002320BC
				public unsafe IKSolverVR.RotationOffset rotationOffset
				{
					get
					{
						IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.RotationOffset.RotationOffsetLink.NativeFieldInfoPtr_rotationOffset);
						return *intPtr;
					}
					set
					{
						*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.RotationOffset.RotationOffsetLink.NativeFieldInfoPtr_rotationOffset)) = value;
					}
				}

				// Token: 0x17002EC1 RID: 11969
				// (get) Token: 0x06008981 RID: 35201 RVA: 0x00233EE0 File Offset: 0x002320E0
				// (set) Token: 0x06008982 RID: 35202 RVA: 0x00233F08 File Offset: 0x00232108
				public unsafe float weight
				{
					get
					{
						IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.RotationOffset.RotationOffsetLink.NativeFieldInfoPtr_weight);
						return *intPtr;
					}
					set
					{
						*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.RotationOffset.RotationOffsetLink.NativeFieldInfoPtr_weight)) = value;
					}
				}

				// Token: 0x17002EC2 RID: 11970
				// (get) Token: 0x06008983 RID: 35203 RVA: 0x00233F2C File Offset: 0x0023212C
				// (set) Token: 0x06008984 RID: 35204 RVA: 0x00233F54 File Offset: 0x00232154
				public unsafe Quaternion lastValue
				{
					get
					{
						IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.RotationOffset.RotationOffsetLink.NativeFieldInfoPtr_lastValue);
						return *intPtr;
					}
					set
					{
						*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.RotationOffset.RotationOffsetLink.NativeFieldInfoPtr_lastValue)) = value;
					}
				}

				// Token: 0x17002EC3 RID: 11971
				// (get) Token: 0x06008985 RID: 35205 RVA: 0x00233F78 File Offset: 0x00232178
				// (set) Token: 0x06008986 RID: 35206 RVA: 0x00233FA0 File Offset: 0x002321A0
				public unsafe Quaternion current
				{
					get
					{
						IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.RotationOffset.RotationOffsetLink.NativeFieldInfoPtr_current);
						return *intPtr;
					}
					set
					{
						*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(HitReactionVRIK.RotationOffset.RotationOffsetLink.NativeFieldInfoPtr_current)) = value;
					}
				}

				// Token: 0x04005BB4 RID: 23476
				private static readonly IntPtr NativeFieldInfoPtr_rotationOffset;

				// Token: 0x04005BB5 RID: 23477
				private static readonly IntPtr NativeFieldInfoPtr_weight;

				// Token: 0x04005BB6 RID: 23478
				private static readonly IntPtr NativeFieldInfoPtr_lastValue;

				// Token: 0x04005BB7 RID: 23479
				private static readonly IntPtr NativeFieldInfoPtr_current;

				// Token: 0x04005BB8 RID: 23480
				private static readonly IntPtr NativeMethodInfoPtr_Apply_Public_Void_VRIK_Quaternion_Single_0;

				// Token: 0x04005BB9 RID: 23481
				private static readonly IntPtr NativeMethodInfoPtr_CrossFadeStart_Public_Void_0;

				// Token: 0x04005BBA RID: 23482
				private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
			}
		}
	}
}