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

namespace RootMotion.FinalIK
{
	// Token: 0x020004DA RID: 1242
	public class HitReactionVRIK : OffsetModifierVRIK
	{
		// Token: 0x060090C9 RID: 37065 RVA: 0x0025272C File Offset: 0x0025092C
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 636567, XrefRangeEnd = 636571, 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: 0x060090CA RID: 37066 RVA: 0x0025277C File Offset: 0x0025097C
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 636571, XrefRangeEnd = 636591, 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: 0x060090CB RID: 37067 RVA: 0x002527FC File Offset: 0x002509FC
		[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: 0x060090CC RID: 37068 RVA: 0x00252848 File Offset: 0x00250A48
		// 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, 100674433);
			HitReactionVRIK.NativeMethodInfoPtr_Hit_Public_Void_Collider_Vector3_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK>.NativeClassPtr, 100674434);
			HitReactionVRIK.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK>.NativeClassPtr, 100674435);
		}

		// Token: 0x060090CD RID: 37069 RVA: 0x002528F0 File Offset: 0x00250AF0
		public HitReactionVRIK(IntPtr pointer)
			: base(pointer)
		{
		}

		// Token: 0x1700310E RID: 12558
		// (get) Token: 0x060090CE RID: 37070 RVA: 0x002528FC File Offset: 0x00250AFC
		// (set) Token: 0x060090CF RID: 37071 RVA: 0x00252930 File Offset: 0x00250B30
		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: 0x1700310F RID: 12559
		// (get) Token: 0x060090D0 RID: 37072 RVA: 0x00252958 File Offset: 0x00250B58
		// (set) Token: 0x060090D1 RID: 37073 RVA: 0x0025298C File Offset: 0x00250B8C
		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: 0x17003110 RID: 12560
		// (get) Token: 0x060090D2 RID: 37074 RVA: 0x002529B4 File Offset: 0x00250BB4
		// (set) Token: 0x060090D3 RID: 37075 RVA: 0x002529E8 File Offset: 0x00250BE8
		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: 0x040060B6 RID: 24758
		private static readonly IntPtr NativeFieldInfoPtr_offsetCurves;

		// Token: 0x040060B7 RID: 24759
		private static readonly IntPtr NativeFieldInfoPtr_positionOffsets;

		// Token: 0x040060B8 RID: 24760
		private static readonly IntPtr NativeFieldInfoPtr_rotationOffsets;

		// Token: 0x040060B9 RID: 24761
		private static readonly IntPtr NativeMethodInfoPtr_OnModifyOffset_Protected_Virtual_Void_0;

		// Token: 0x040060BA RID: 24762
		private static readonly IntPtr NativeMethodInfoPtr_Hit_Public_Void_Collider_Vector3_Vector3_0;

		// Token: 0x040060BB RID: 24763
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

		// Token: 0x020004DB RID: 1243
		[Serializable]
		public class Offset : Il2CppSystem.Object
		{
			// Token: 0x1700311B RID: 12571
			// (get) Token: 0x060090D4 RID: 37076 RVA: 0x00252A10 File Offset: 0x00250C10
			// (set) Token: 0x060090D5 RID: 37077 RVA: 0x00252A60 File Offset: 0x00250C60
			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 = 225924, RefRangeEnd = 225925, XrefRangeStart = 225924, XrefRangeEnd = 225925, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
				set
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					checked
					{
						IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
						*ptr = ref value;
						IntPtr intPtr2;
						IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(HitReactionVRIK.Offset.NativeMethodInfoPtr_set_crossFader_Private_set_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
						Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					}
				}
			}

			// Token: 0x1700311C RID: 12572
			// (get) Token: 0x060090D6 RID: 37078 RVA: 0x00252AB4 File Offset: 0x00250CB4
			// (set) Token: 0x060090D7 RID: 37079 RVA: 0x00252B04 File Offset: 0x00250D04
			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 = 225930, RefRangeEnd = 225932, XrefRangeStart = 225930, XrefRangeEnd = 225932, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
				set
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					checked
					{
						IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
						*ptr = ref value;
						IntPtr intPtr2;
						IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(HitReactionVRIK.Offset.NativeMethodInfoPtr_set_timer_Private_set_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
						Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					}
				}
			}

			// Token: 0x1700311D RID: 12573
			// (get) Token: 0x060090D8 RID: 37080 RVA: 0x00252B58 File Offset: 0x00250D58
			// (set) Token: 0x060090D9 RID: 37081 RVA: 0x00252BA8 File Offset: 0x00250DA8
			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: 0x1700311E RID: 12574
			// (get) Token: 0x060090DA RID: 37082 RVA: 0x00252BFC File Offset: 0x00250DFC
			// (set) Token: 0x060090DB RID: 37083 RVA: 0x00252C4C File Offset: 0x00250E4C
			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: 0x060090DC RID: 37084 RVA: 0x00252CA0 File Offset: 0x00250EA0
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 636476, RefRangeEnd = 636478, XrefRangeStart = 636468, XrefRangeEnd = 636476, 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: 0x060090DD RID: 37085 RVA: 0x00252D20 File Offset: 0x00250F20
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 636483, RefRangeEnd = 636485, XrefRangeStart = 636478, XrefRangeEnd = 636483, 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: 0x060090DE RID: 37086 RVA: 0x00252DA4 File Offset: 0x00250FA4
			[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: 0x060090DF RID: 37087 RVA: 0x00252E18 File Offset: 0x00251018
			[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: 0x060090E0 RID: 37088 RVA: 0x00252E68 File Offset: 0x00251068
			[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: 0x060090E1 RID: 37089 RVA: 0x00252EF8 File Offset: 0x002510F8
			[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: 0x060090E2 RID: 37090 RVA: 0x00252F44 File Offset: 0x00251144
			// 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, 100674436);
				HitReactionVRIK.Offset.NativeMethodInfoPtr_set_crossFader_Private_set_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, 100674437);
				HitReactionVRIK.Offset.NativeMethodInfoPtr_get_timer_Protected_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, 100674438);
				HitReactionVRIK.Offset.NativeMethodInfoPtr_set_timer_Private_set_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, 100674439);
				HitReactionVRIK.Offset.NativeMethodInfoPtr_get_force_Protected_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, 100674440);
				HitReactionVRIK.Offset.NativeMethodInfoPtr_set_force_Private_set_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, 100674441);
				HitReactionVRIK.Offset.NativeMethodInfoPtr_get_point_Protected_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, 100674442);
				HitReactionVRIK.Offset.NativeMethodInfoPtr_set_point_Private_set_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, 100674443);
				HitReactionVRIK.Offset.NativeMethodInfoPtr_Hit_Public_Void_Vector3_Il2CppReferenceArray_1_AnimationCurve_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, 100674444);
				HitReactionVRIK.Offset.NativeMethodInfoPtr_Apply_Public_Void_VRIK_Il2CppReferenceArray_1_AnimationCurve_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, 100674445);
				HitReactionVRIK.Offset.NativeMethodInfoPtr_GetLength_Protected_Abstract_Virtual_New_Single_Il2CppReferenceArray_1_AnimationCurve_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, 100674446);
				HitReactionVRIK.Offset.NativeMethodInfoPtr_CrossFadeStart_Protected_Abstract_Virtual_New_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, 100674447);
				HitReactionVRIK.Offset.NativeMethodInfoPtr_OnApply_Protected_Abstract_Virtual_New_Void_VRIK_Il2CppReferenceArray_1_AnimationCurve_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, 100674448);
				HitReactionVRIK.Offset.NativeMethodInfoPtr__ctor_Protected_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, 100674449);
			}

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

			// Token: 0x17003111 RID: 12561
			// (get) Token: 0x060090E4 RID: 37092 RVA: 0x00253150 File Offset: 0x00251350
			// (set) Token: 0x060090E5 RID: 37093 RVA: 0x00253179 File Offset: 0x00251379
			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: 0x17003112 RID: 12562
			// (get) Token: 0x060090E6 RID: 37094 RVA: 0x002531A0 File Offset: 0x002513A0
			// (set) Token: 0x060090E7 RID: 37095 RVA: 0x002531D4 File Offset: 0x002513D4
			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: 0x17003113 RID: 12563
			// (get) Token: 0x060090E8 RID: 37096 RVA: 0x002531FC File Offset: 0x002513FC
			// (set) Token: 0x060090E9 RID: 37097 RVA: 0x00253224 File Offset: 0x00251424
			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: 0x17003114 RID: 12564
			// (get) Token: 0x060090EA RID: 37098 RVA: 0x00253248 File Offset: 0x00251448
			// (set) Token: 0x060090EB RID: 37099 RVA: 0x00253270 File Offset: 0x00251470
			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: 0x17003115 RID: 12565
			// (get) Token: 0x060090EC RID: 37100 RVA: 0x00253294 File Offset: 0x00251494
			// (set) Token: 0x060090ED RID: 37101 RVA: 0x002532BC File Offset: 0x002514BC
			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: 0x17003116 RID: 12566
			// (get) Token: 0x060090EE RID: 37102 RVA: 0x002532E0 File Offset: 0x002514E0
			// (set) Token: 0x060090EF RID: 37103 RVA: 0x00253308 File Offset: 0x00251508
			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: 0x17003117 RID: 12567
			// (get) Token: 0x060090F0 RID: 37104 RVA: 0x0025332C File Offset: 0x0025152C
			// (set) Token: 0x060090F1 RID: 37105 RVA: 0x00253354 File Offset: 0x00251554
			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: 0x17003118 RID: 12568
			// (get) Token: 0x060090F2 RID: 37106 RVA: 0x00253378 File Offset: 0x00251578
			// (set) Token: 0x060090F3 RID: 37107 RVA: 0x002533A0 File Offset: 0x002515A0
			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: 0x17003119 RID: 12569
			// (get) Token: 0x060090F4 RID: 37108 RVA: 0x002533C4 File Offset: 0x002515C4
			// (set) Token: 0x060090F5 RID: 37109 RVA: 0x002533EC File Offset: 0x002515EC
			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: 0x1700311A RID: 12570
			// (get) Token: 0x060090F6 RID: 37110 RVA: 0x00253410 File Offset: 0x00251610
			// (set) Token: 0x060090F7 RID: 37111 RVA: 0x00253438 File Offset: 0x00251638
			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: 0x040060BC RID: 24764
			private static readonly IntPtr NativeFieldInfoPtr_name;

			// Token: 0x040060BD RID: 24765
			private static readonly IntPtr NativeFieldInfoPtr_collider;

			// Token: 0x040060BE RID: 24766
			private static readonly IntPtr NativeFieldInfoPtr_crossFadeTime;

			// Token: 0x040060BF RID: 24767
			private static readonly IntPtr NativeFieldInfoPtr__crossFader_k__BackingField;

			// Token: 0x040060C0 RID: 24768
			private static readonly IntPtr NativeFieldInfoPtr__timer_k__BackingField;

			// Token: 0x040060C1 RID: 24769
			private static readonly IntPtr NativeFieldInfoPtr__force_k__BackingField;

			// Token: 0x040060C2 RID: 24770
			private static readonly IntPtr NativeFieldInfoPtr__point_k__BackingField;

			// Token: 0x040060C3 RID: 24771
			private static readonly IntPtr NativeFieldInfoPtr_length;

			// Token: 0x040060C4 RID: 24772
			private static readonly IntPtr NativeFieldInfoPtr_crossFadeSpeed;

			// Token: 0x040060C5 RID: 24773
			private static readonly IntPtr NativeFieldInfoPtr_lastTime;

			// Token: 0x040060C6 RID: 24774
			private static readonly IntPtr NativeMethodInfoPtr_get_crossFader_Protected_get_Single_0;

			// Token: 0x040060C7 RID: 24775
			private static readonly IntPtr NativeMethodInfoPtr_set_crossFader_Private_set_Void_Single_0;

			// Token: 0x040060C8 RID: 24776
			private static readonly IntPtr NativeMethodInfoPtr_get_timer_Protected_get_Single_0;

			// Token: 0x040060C9 RID: 24777
			private static readonly IntPtr NativeMethodInfoPtr_set_timer_Private_set_Void_Single_0;

			// Token: 0x040060CA RID: 24778
			private static readonly IntPtr NativeMethodInfoPtr_get_force_Protected_get_Vector3_0;

			// Token: 0x040060CB RID: 24779
			private static readonly IntPtr NativeMethodInfoPtr_set_force_Private_set_Void_Vector3_0;

			// Token: 0x040060CC RID: 24780
			private static readonly IntPtr NativeMethodInfoPtr_get_point_Protected_get_Vector3_0;

			// Token: 0x040060CD RID: 24781
			private static readonly IntPtr NativeMethodInfoPtr_set_point_Private_set_Void_Vector3_0;

			// Token: 0x040060CE RID: 24782
			private static readonly IntPtr NativeMethodInfoPtr_Hit_Public_Void_Vector3_Il2CppReferenceArray_1_AnimationCurve_Vector3_0;

			// Token: 0x040060CF RID: 24783
			private static readonly IntPtr NativeMethodInfoPtr_Apply_Public_Void_VRIK_Il2CppReferenceArray_1_AnimationCurve_Single_0;

			// Token: 0x040060D0 RID: 24784
			private static readonly IntPtr NativeMethodInfoPtr_GetLength_Protected_Abstract_Virtual_New_Single_Il2CppReferenceArray_1_AnimationCurve_0;

			// Token: 0x040060D1 RID: 24785
			private static readonly IntPtr NativeMethodInfoPtr_CrossFadeStart_Protected_Abstract_Virtual_New_Void_0;

			// Token: 0x040060D2 RID: 24786
			private static readonly IntPtr NativeMethodInfoPtr_OnApply_Protected_Abstract_Virtual_New_Void_VRIK_Il2CppReferenceArray_1_AnimationCurve_Single_0;

			// Token: 0x040060D3 RID: 24787
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Protected_Void_0;
		}

		// Token: 0x020004DC RID: 1244
		[Serializable]
		public class PositionOffset : HitReactionVRIK.Offset
		{
			// Token: 0x060090F8 RID: 37112 RVA: 0x0025345C File Offset: 0x0025165C
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 636488, XrefRangeEnd = 636515, 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: 0x060090F9 RID: 37113 RVA: 0x002534D0 File Offset: 0x002516D0
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 636515, XrefRangeEnd = 636517, 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: 0x060090FA RID: 37114 RVA: 0x00253520 File Offset: 0x00251720
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 636517, XrefRangeEnd = 636524, 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: 0x060090FB RID: 37115 RVA: 0x002535B0 File Offset: 0x002517B0
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 636524, XrefRangeEnd = 636525, 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: 0x060090FC RID: 37116 RVA: 0x002535FC File Offset: 0x002517FC
			// 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, 100674450);
				HitReactionVRIK.PositionOffset.NativeMethodInfoPtr_CrossFadeStart_Protected_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.PositionOffset>.NativeClassPtr, 100674451);
				HitReactionVRIK.PositionOffset.NativeMethodInfoPtr_OnApply_Protected_Virtual_Void_VRIK_Il2CppReferenceArray_1_AnimationCurve_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.PositionOffset>.NativeClassPtr, 100674452);
				HitReactionVRIK.PositionOffset.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.PositionOffset>.NativeClassPtr, 100674453);
			}

			// Token: 0x060090FD RID: 37117 RVA: 0x002536B3 File Offset: 0x002518B3
			public PositionOffset(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x1700311F RID: 12575
			// (get) Token: 0x060090FE RID: 37118 RVA: 0x002536BC File Offset: 0x002518BC
			// (set) Token: 0x060090FF RID: 37119 RVA: 0x002536E4 File Offset: 0x002518E4
			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: 0x17003120 RID: 12576
			// (get) Token: 0x06009100 RID: 37120 RVA: 0x00253708 File Offset: 0x00251908
			// (set) Token: 0x06009101 RID: 37121 RVA: 0x00253730 File Offset: 0x00251930
			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: 0x17003121 RID: 12577
			// (get) Token: 0x06009102 RID: 37122 RVA: 0x00253754 File Offset: 0x00251954
			// (set) Token: 0x06009103 RID: 37123 RVA: 0x00253788 File Offset: 0x00251988
			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: 0x040060D4 RID: 24788
			private static readonly IntPtr NativeFieldInfoPtr_forceDirCurveIndex;

			// Token: 0x040060D5 RID: 24789
			private static readonly IntPtr NativeFieldInfoPtr_upDirCurveIndex;

			// Token: 0x040060D6 RID: 24790
			private static readonly IntPtr NativeFieldInfoPtr_offsetLinks;

			// Token: 0x040060D7 RID: 24791
			private static readonly IntPtr NativeMethodInfoPtr_GetLength_Protected_Virtual_Single_Il2CppReferenceArray_1_AnimationCurve_0;

			// Token: 0x040060D8 RID: 24792
			private static readonly IntPtr NativeMethodInfoPtr_CrossFadeStart_Protected_Virtual_Void_0;

			// Token: 0x040060D9 RID: 24793
			private static readonly IntPtr NativeMethodInfoPtr_OnApply_Protected_Virtual_Void_VRIK_Il2CppReferenceArray_1_AnimationCurve_Single_0;

			// Token: 0x040060DA RID: 24794
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

			// Token: 0x020004DD RID: 1245
			[Serializable]
			public class PositionOffsetLink : Il2CppSystem.Object
			{
				// Token: 0x06009104 RID: 37124 RVA: 0x002537B0 File Offset: 0x002519B0
				[CallerCount(1)]
				[CachedScanResults(RefRangeStart = 636487, RefRangeEnd = 636488, XrefRangeStart = 636485, XrefRangeEnd = 636487, 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: 0x06009105 RID: 37125 RVA: 0x00253830 File Offset: 0x00251A30
				[CallerCount(2)]
				[CachedScanResults(RefRangeStart = 636380, RefRangeEnd = 636382, XrefRangeStart = 636380, XrefRangeEnd = 636382, 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: 0x06009106 RID: 37126 RVA: 0x00253874 File Offset: 0x00251A74
				[CallerCount(1664)]
				[CachedScanResults(RefRangeStart = 7711, RefRangeEnd = 9375, XrefRangeStart = 7711, XrefRangeEnd = 9375, 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: 0x06009107 RID: 37127 RVA: 0x002538C0 File Offset: 0x00251AC0
				// 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, 100674454);
					HitReactionVRIK.PositionOffset.PositionOffsetLink.NativeMethodInfoPtr_CrossFadeStart_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.PositionOffset.PositionOffsetLink>.NativeClassPtr, 100674455);
					HitReactionVRIK.PositionOffset.PositionOffsetLink.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.PositionOffset.PositionOffsetLink>.NativeClassPtr, 100674456);
				}

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

				// Token: 0x17003122 RID: 12578
				// (get) Token: 0x06009109 RID: 37129 RVA: 0x00253978 File Offset: 0x00251B78
				// (set) Token: 0x0600910A RID: 37130 RVA: 0x002539A0 File Offset: 0x00251BA0
				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: 0x17003123 RID: 12579
				// (get) Token: 0x0600910B RID: 37131 RVA: 0x002539C4 File Offset: 0x00251BC4
				// (set) Token: 0x0600910C RID: 37132 RVA: 0x002539EC File Offset: 0x00251BEC
				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: 0x17003124 RID: 12580
				// (get) Token: 0x0600910D RID: 37133 RVA: 0x00253A10 File Offset: 0x00251C10
				// (set) Token: 0x0600910E RID: 37134 RVA: 0x00253A38 File Offset: 0x00251C38
				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: 0x17003125 RID: 12581
				// (get) Token: 0x0600910F RID: 37135 RVA: 0x00253A5C File Offset: 0x00251C5C
				// (set) Token: 0x06009110 RID: 37136 RVA: 0x00253A84 File Offset: 0x00251C84
				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: 0x040060DB RID: 24795
				private static readonly IntPtr NativeFieldInfoPtr_positionOffset;

				// Token: 0x040060DC RID: 24796
				private static readonly IntPtr NativeFieldInfoPtr_weight;

				// Token: 0x040060DD RID: 24797
				private static readonly IntPtr NativeFieldInfoPtr_lastValue;

				// Token: 0x040060DE RID: 24798
				private static readonly IntPtr NativeFieldInfoPtr_current;

				// Token: 0x040060DF RID: 24799
				private static readonly IntPtr NativeMethodInfoPtr_Apply_Public_Void_VRIK_Vector3_Single_0;

				// Token: 0x040060E0 RID: 24800
				private static readonly IntPtr NativeMethodInfoPtr_CrossFadeStart_Public_Void_0;

				// Token: 0x040060E1 RID: 24801
				private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
			}
		}

		// Token: 0x020004DE RID: 1246
		[Serializable]
		public class RotationOffset : HitReactionVRIK.Offset
		{
			// Token: 0x06009111 RID: 37137 RVA: 0x00253AA8 File Offset: 0x00251CA8
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 636534, XrefRangeEnd = 636538, 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: 0x06009112 RID: 37138 RVA: 0x00253B1C File Offset: 0x00251D1C
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 636538, XrefRangeEnd = 636540, 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: 0x06009113 RID: 37139 RVA: 0x00253B6C File Offset: 0x00251D6C
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 636540, XrefRangeEnd = 636567, 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: 0x06009114 RID: 37140 RVA: 0x00253BFC File Offset: 0x00251DFC
			[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: 0x06009115 RID: 37141 RVA: 0x00253C48 File Offset: 0x00251E48
			// 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, 100674457);
				HitReactionVRIK.RotationOffset.NativeMethodInfoPtr_CrossFadeStart_Protected_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.RotationOffset>.NativeClassPtr, 100674458);
				HitReactionVRIK.RotationOffset.NativeMethodInfoPtr_OnApply_Protected_Virtual_Void_VRIK_Il2CppReferenceArray_1_AnimationCurve_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.RotationOffset>.NativeClassPtr, 100674459);
				HitReactionVRIK.RotationOffset.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.RotationOffset>.NativeClassPtr, 100674460);
			}

			// Token: 0x06009116 RID: 37142 RVA: 0x002536B3 File Offset: 0x002518B3
			public RotationOffset(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17003126 RID: 12582
			// (get) Token: 0x06009117 RID: 37143 RVA: 0x00253D00 File Offset: 0x00251F00
			// (set) Token: 0x06009118 RID: 37144 RVA: 0x00253D28 File Offset: 0x00251F28
			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: 0x17003127 RID: 12583
			// (get) Token: 0x06009119 RID: 37145 RVA: 0x00253D4C File Offset: 0x00251F4C
			// (set) Token: 0x0600911A RID: 37146 RVA: 0x00253D80 File Offset: 0x00251F80
			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: 0x17003128 RID: 12584
			// (get) Token: 0x0600911B RID: 37147 RVA: 0x00253DA8 File Offset: 0x00251FA8
			// (set) Token: 0x0600911C RID: 37148 RVA: 0x00253DDC File Offset: 0x00251FDC
			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: 0x040060E2 RID: 24802
			private static readonly IntPtr NativeFieldInfoPtr_curveIndex;

			// Token: 0x040060E3 RID: 24803
			private static readonly IntPtr NativeFieldInfoPtr_offsetLinks;

			// Token: 0x040060E4 RID: 24804
			private static readonly IntPtr NativeFieldInfoPtr_rigidbody;

			// Token: 0x040060E5 RID: 24805
			private static readonly IntPtr NativeMethodInfoPtr_GetLength_Protected_Virtual_Single_Il2CppReferenceArray_1_AnimationCurve_0;

			// Token: 0x040060E6 RID: 24806
			private static readonly IntPtr NativeMethodInfoPtr_CrossFadeStart_Protected_Virtual_Void_0;

			// Token: 0x040060E7 RID: 24807
			private static readonly IntPtr NativeMethodInfoPtr_OnApply_Protected_Virtual_Void_VRIK_Il2CppReferenceArray_1_AnimationCurve_Single_0;

			// Token: 0x040060E8 RID: 24808
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

			// Token: 0x020004DF RID: 1247
			[Serializable]
			public class RotationOffsetLink : Il2CppSystem.Object
			{
				// Token: 0x0600911D RID: 37149 RVA: 0x00253E04 File Offset: 0x00252004
				[CallerCount(1)]
				[CachedScanResults(RefRangeStart = 636529, RefRangeEnd = 636530, XrefRangeStart = 636525, XrefRangeEnd = 636529, 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: 0x0600911E RID: 37150 RVA: 0x00253E84 File Offset: 0x00252084
				[CallerCount(1)]
				[CachedScanResults(RefRangeStart = 636530, RefRangeEnd = 636531, XrefRangeStart = 636530, XrefRangeEnd = 636530, 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: 0x0600911F RID: 37151 RVA: 0x00253EC8 File Offset: 0x002520C8
				[CallerCount(0)]
				[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 636531, XrefRangeEnd = 636534, 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: 0x06009120 RID: 37152 RVA: 0x00253F14 File Offset: 0x00252114
				// 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, 100674461);
					HitReactionVRIK.RotationOffset.RotationOffsetLink.NativeMethodInfoPtr_CrossFadeStart_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.RotationOffset.RotationOffsetLink>.NativeClassPtr, 100674462);
					HitReactionVRIK.RotationOffset.RotationOffsetLink.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.RotationOffset.RotationOffsetLink>.NativeClassPtr, 100674463);
				}

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

				// Token: 0x17003129 RID: 12585
				// (get) Token: 0x06009122 RID: 37154 RVA: 0x00253FCC File Offset: 0x002521CC
				// (set) Token: 0x06009123 RID: 37155 RVA: 0x00253FF4 File Offset: 0x002521F4
				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: 0x1700312A RID: 12586
				// (get) Token: 0x06009124 RID: 37156 RVA: 0x00254018 File Offset: 0x00252218
				// (set) Token: 0x06009125 RID: 37157 RVA: 0x00254040 File Offset: 0x00252240
				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: 0x1700312B RID: 12587
				// (get) Token: 0x06009126 RID: 37158 RVA: 0x00254064 File Offset: 0x00252264
				// (set) Token: 0x06009127 RID: 37159 RVA: 0x0025408C File Offset: 0x0025228C
				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: 0x1700312C RID: 12588
				// (get) Token: 0x06009128 RID: 37160 RVA: 0x002540B0 File Offset: 0x002522B0
				// (set) Token: 0x06009129 RID: 37161 RVA: 0x002540D8 File Offset: 0x002522D8
				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: 0x040060E9 RID: 24809
				private static readonly IntPtr NativeFieldInfoPtr_rotationOffset;

				// Token: 0x040060EA RID: 24810
				private static readonly IntPtr NativeFieldInfoPtr_weight;

				// Token: 0x040060EB RID: 24811
				private static readonly IntPtr NativeFieldInfoPtr_lastValue;

				// Token: 0x040060EC RID: 24812
				private static readonly IntPtr NativeFieldInfoPtr_current;

				// Token: 0x040060ED RID: 24813
				private static readonly IntPtr NativeMethodInfoPtr_Apply_Public_Void_VRIK_Quaternion_Single_0;

				// Token: 0x040060EE RID: 24814
				private static readonly IntPtr NativeMethodInfoPtr_CrossFadeStart_Public_Void_0;

				// Token: 0x040060EF RID: 24815
				private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
			}
		}
	}
}
