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

namespace RootMotion.FinalIK
{
	// Token: 0x02000482 RID: 1154
	public class HitReactionVRIK : OffsetModifierVRIK
	{
		// Token: 0x06008876 RID: 34934 RVA: 0x0022F9F0 File Offset: 0x0022DBF0
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 604257, XrefRangeEnd = 604261, 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: 0x06008877 RID: 34935 RVA: 0x0022FA40 File Offset: 0x0022DC40
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 604261, XrefRangeEnd = 604281, 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: 0x06008878 RID: 34936 RVA: 0x0022FAC0 File Offset: 0x0022DCC0
		[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: 0x06008879 RID: 34937 RVA: 0x0022FB0C File Offset: 0x0022DD0C
		// 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, 100673720);
			HitReactionVRIK.NativeMethodInfoPtr_Hit_Public_Void_Collider_Vector3_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK>.NativeClassPtr, 100673721);
			HitReactionVRIK.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK>.NativeClassPtr, 100673722);
		}

		// Token: 0x0600887A RID: 34938 RVA: 0x0022FBB4 File Offset: 0x0022DDB4
		public HitReactionVRIK(IntPtr pointer)
			: base(pointer)
		{
		}

		// Token: 0x17002E73 RID: 11891
		// (get) Token: 0x0600887B RID: 34939 RVA: 0x0022FBC0 File Offset: 0x0022DDC0
		// (set) Token: 0x0600887C RID: 34940 RVA: 0x0022FBF4 File Offset: 0x0022DDF4
		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: 0x17002E74 RID: 11892
		// (get) Token: 0x0600887D RID: 34941 RVA: 0x0022FC1C File Offset: 0x0022DE1C
		// (set) Token: 0x0600887E RID: 34942 RVA: 0x0022FC50 File Offset: 0x0022DE50
		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: 0x17002E75 RID: 11893
		// (get) Token: 0x0600887F RID: 34943 RVA: 0x0022FC78 File Offset: 0x0022DE78
		// (set) Token: 0x06008880 RID: 34944 RVA: 0x0022FCAC File Offset: 0x0022DEAC
		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: 0x04005B0D RID: 23309
		private static readonly IntPtr NativeFieldInfoPtr_offsetCurves;

		// Token: 0x04005B0E RID: 23310
		private static readonly IntPtr NativeFieldInfoPtr_positionOffsets;

		// Token: 0x04005B0F RID: 23311
		private static readonly IntPtr NativeFieldInfoPtr_rotationOffsets;

		// Token: 0x04005B10 RID: 23312
		private static readonly IntPtr NativeMethodInfoPtr_OnModifyOffset_Protected_Virtual_Void_0;

		// Token: 0x04005B11 RID: 23313
		private static readonly IntPtr NativeMethodInfoPtr_Hit_Public_Void_Collider_Vector3_Vector3_0;

		// Token: 0x04005B12 RID: 23314
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

		// Token: 0x02000483 RID: 1155
		[Serializable]
		public class Offset : Il2CppSystem.Object
		{
			// Token: 0x17002E80 RID: 11904
			// (get) Token: 0x06008881 RID: 34945 RVA: 0x0022FCD4 File Offset: 0x0022DED4
			// (set) Token: 0x06008882 RID: 34946 RVA: 0x0022FD24 File Offset: 0x0022DF24
			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 = 218204, RefRangeEnd = 218205, XrefRangeStart = 218204, XrefRangeEnd = 218205, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
				set
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					checked
					{
						IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
						*ptr = ref value;
						IntPtr intPtr2;
						IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(HitReactionVRIK.Offset.NativeMethodInfoPtr_set_crossFader_Private_set_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
						Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					}
				}
			}

			// Token: 0x17002E81 RID: 11905
			// (get) Token: 0x06008883 RID: 34947 RVA: 0x0022FD78 File Offset: 0x0022DF78
			// (set) Token: 0x06008884 RID: 34948 RVA: 0x0022FDC8 File Offset: 0x0022DFC8
			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 = 218210, RefRangeEnd = 218212, XrefRangeStart = 218210, XrefRangeEnd = 218212, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
				set
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					checked
					{
						IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
						*ptr = ref value;
						IntPtr intPtr2;
						IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(HitReactionVRIK.Offset.NativeMethodInfoPtr_set_timer_Private_set_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
						Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					}
				}
			}

			// Token: 0x17002E82 RID: 11906
			// (get) Token: 0x06008885 RID: 34949 RVA: 0x0022FE1C File Offset: 0x0022E01C
			// (set) Token: 0x06008886 RID: 34950 RVA: 0x0022FE6C File Offset: 0x0022E06C
			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: 0x17002E83 RID: 11907
			// (get) Token: 0x06008887 RID: 34951 RVA: 0x0022FEC0 File Offset: 0x0022E0C0
			// (set) Token: 0x06008888 RID: 34952 RVA: 0x0022FF10 File Offset: 0x0022E110
			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: 0x06008889 RID: 34953 RVA: 0x0022FF64 File Offset: 0x0022E164
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 604166, RefRangeEnd = 604168, XrefRangeStart = 604158, XrefRangeEnd = 604166, 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: 0x0600888A RID: 34954 RVA: 0x0022FFE4 File Offset: 0x0022E1E4
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 604173, RefRangeEnd = 604175, XrefRangeStart = 604168, XrefRangeEnd = 604173, 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: 0x0600888B RID: 34955 RVA: 0x00230068 File Offset: 0x0022E268
			[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: 0x0600888C RID: 34956 RVA: 0x002300DC File Offset: 0x0022E2DC
			[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: 0x0600888D RID: 34957 RVA: 0x0023012C File Offset: 0x0022E32C
			[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: 0x0600888E RID: 34958 RVA: 0x002301BC File Offset: 0x0022E3BC
			[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: 0x0600888F RID: 34959 RVA: 0x00230208 File Offset: 0x0022E408
			// 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, 100673723);
				HitReactionVRIK.Offset.NativeMethodInfoPtr_set_crossFader_Private_set_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, 100673724);
				HitReactionVRIK.Offset.NativeMethodInfoPtr_get_timer_Protected_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, 100673725);
				HitReactionVRIK.Offset.NativeMethodInfoPtr_set_timer_Private_set_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, 100673726);
				HitReactionVRIK.Offset.NativeMethodInfoPtr_get_force_Protected_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, 100673727);
				HitReactionVRIK.Offset.NativeMethodInfoPtr_set_force_Private_set_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, 100673728);
				HitReactionVRIK.Offset.NativeMethodInfoPtr_get_point_Protected_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, 100673729);
				HitReactionVRIK.Offset.NativeMethodInfoPtr_set_point_Private_set_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, 100673730);
				HitReactionVRIK.Offset.NativeMethodInfoPtr_Hit_Public_Void_Vector3_Il2CppReferenceArray_1_AnimationCurve_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, 100673731);
				HitReactionVRIK.Offset.NativeMethodInfoPtr_Apply_Public_Void_VRIK_Il2CppReferenceArray_1_AnimationCurve_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, 100673732);
				HitReactionVRIK.Offset.NativeMethodInfoPtr_GetLength_Protected_Abstract_Virtual_New_Single_Il2CppReferenceArray_1_AnimationCurve_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, 100673733);
				HitReactionVRIK.Offset.NativeMethodInfoPtr_CrossFadeStart_Protected_Abstract_Virtual_New_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, 100673734);
				HitReactionVRIK.Offset.NativeMethodInfoPtr_OnApply_Protected_Abstract_Virtual_New_Void_VRIK_Il2CppReferenceArray_1_AnimationCurve_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, 100673735);
				HitReactionVRIK.Offset.NativeMethodInfoPtr__ctor_Protected_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.Offset>.NativeClassPtr, 100673736);
			}

			// Token: 0x06008890 RID: 34960 RVA: 0x0000A688 File Offset: 0x00008888
			public Offset(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002E76 RID: 11894
			// (get) Token: 0x06008891 RID: 34961 RVA: 0x00230414 File Offset: 0x0022E614
			// (set) Token: 0x06008892 RID: 34962 RVA: 0x0023043D File Offset: 0x0022E63D
			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: 0x17002E77 RID: 11895
			// (get) Token: 0x06008893 RID: 34963 RVA: 0x00230464 File Offset: 0x0022E664
			// (set) Token: 0x06008894 RID: 34964 RVA: 0x00230498 File Offset: 0x0022E698
			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: 0x17002E78 RID: 11896
			// (get) Token: 0x06008895 RID: 34965 RVA: 0x002304C0 File Offset: 0x0022E6C0
			// (set) Token: 0x06008896 RID: 34966 RVA: 0x002304E8 File Offset: 0x0022E6E8
			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: 0x17002E79 RID: 11897
			// (get) Token: 0x06008897 RID: 34967 RVA: 0x0023050C File Offset: 0x0022E70C
			// (set) Token: 0x06008898 RID: 34968 RVA: 0x00230534 File Offset: 0x0022E734
			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: 0x17002E7A RID: 11898
			// (get) Token: 0x06008899 RID: 34969 RVA: 0x00230558 File Offset: 0x0022E758
			// (set) Token: 0x0600889A RID: 34970 RVA: 0x00230580 File Offset: 0x0022E780
			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: 0x17002E7B RID: 11899
			// (get) Token: 0x0600889B RID: 34971 RVA: 0x002305A4 File Offset: 0x0022E7A4
			// (set) Token: 0x0600889C RID: 34972 RVA: 0x002305CC File Offset: 0x0022E7CC
			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: 0x17002E7C RID: 11900
			// (get) Token: 0x0600889D RID: 34973 RVA: 0x002305F0 File Offset: 0x0022E7F0
			// (set) Token: 0x0600889E RID: 34974 RVA: 0x00230618 File Offset: 0x0022E818
			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: 0x17002E7D RID: 11901
			// (get) Token: 0x0600889F RID: 34975 RVA: 0x0023063C File Offset: 0x0022E83C
			// (set) Token: 0x060088A0 RID: 34976 RVA: 0x00230664 File Offset: 0x0022E864
			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: 0x17002E7E RID: 11902
			// (get) Token: 0x060088A1 RID: 34977 RVA: 0x00230688 File Offset: 0x0022E888
			// (set) Token: 0x060088A2 RID: 34978 RVA: 0x002306B0 File Offset: 0x0022E8B0
			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: 0x17002E7F RID: 11903
			// (get) Token: 0x060088A3 RID: 34979 RVA: 0x002306D4 File Offset: 0x0022E8D4
			// (set) Token: 0x060088A4 RID: 34980 RVA: 0x002306FC File Offset: 0x0022E8FC
			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: 0x04005B13 RID: 23315
			private static readonly IntPtr NativeFieldInfoPtr_name;

			// Token: 0x04005B14 RID: 23316
			private static readonly IntPtr NativeFieldInfoPtr_collider;

			// Token: 0x04005B15 RID: 23317
			private static readonly IntPtr NativeFieldInfoPtr_crossFadeTime;

			// Token: 0x04005B16 RID: 23318
			private static readonly IntPtr NativeFieldInfoPtr__crossFader_k__BackingField;

			// Token: 0x04005B17 RID: 23319
			private static readonly IntPtr NativeFieldInfoPtr__timer_k__BackingField;

			// Token: 0x04005B18 RID: 23320
			private static readonly IntPtr NativeFieldInfoPtr__force_k__BackingField;

			// Token: 0x04005B19 RID: 23321
			private static readonly IntPtr NativeFieldInfoPtr__point_k__BackingField;

			// Token: 0x04005B1A RID: 23322
			private static readonly IntPtr NativeFieldInfoPtr_length;

			// Token: 0x04005B1B RID: 23323
			private static readonly IntPtr NativeFieldInfoPtr_crossFadeSpeed;

			// Token: 0x04005B1C RID: 23324
			private static readonly IntPtr NativeFieldInfoPtr_lastTime;

			// Token: 0x04005B1D RID: 23325
			private static readonly IntPtr NativeMethodInfoPtr_get_crossFader_Protected_get_Single_0;

			// Token: 0x04005B1E RID: 23326
			private static readonly IntPtr NativeMethodInfoPtr_set_crossFader_Private_set_Void_Single_0;

			// Token: 0x04005B1F RID: 23327
			private static readonly IntPtr NativeMethodInfoPtr_get_timer_Protected_get_Single_0;

			// Token: 0x04005B20 RID: 23328
			private static readonly IntPtr NativeMethodInfoPtr_set_timer_Private_set_Void_Single_0;

			// Token: 0x04005B21 RID: 23329
			private static readonly IntPtr NativeMethodInfoPtr_get_force_Protected_get_Vector3_0;

			// Token: 0x04005B22 RID: 23330
			private static readonly IntPtr NativeMethodInfoPtr_set_force_Private_set_Void_Vector3_0;

			// Token: 0x04005B23 RID: 23331
			private static readonly IntPtr NativeMethodInfoPtr_get_point_Protected_get_Vector3_0;

			// Token: 0x04005B24 RID: 23332
			private static readonly IntPtr NativeMethodInfoPtr_set_point_Private_set_Void_Vector3_0;

			// Token: 0x04005B25 RID: 23333
			private static readonly IntPtr NativeMethodInfoPtr_Hit_Public_Void_Vector3_Il2CppReferenceArray_1_AnimationCurve_Vector3_0;

			// Token: 0x04005B26 RID: 23334
			private static readonly IntPtr NativeMethodInfoPtr_Apply_Public_Void_VRIK_Il2CppReferenceArray_1_AnimationCurve_Single_0;

			// Token: 0x04005B27 RID: 23335
			private static readonly IntPtr NativeMethodInfoPtr_GetLength_Protected_Abstract_Virtual_New_Single_Il2CppReferenceArray_1_AnimationCurve_0;

			// Token: 0x04005B28 RID: 23336
			private static readonly IntPtr NativeMethodInfoPtr_CrossFadeStart_Protected_Abstract_Virtual_New_Void_0;

			// Token: 0x04005B29 RID: 23337
			private static readonly IntPtr NativeMethodInfoPtr_OnApply_Protected_Abstract_Virtual_New_Void_VRIK_Il2CppReferenceArray_1_AnimationCurve_Single_0;

			// Token: 0x04005B2A RID: 23338
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Protected_Void_0;
		}

		// Token: 0x02000484 RID: 1156
		[Serializable]
		public class PositionOffset : HitReactionVRIK.Offset
		{
			// Token: 0x060088A5 RID: 34981 RVA: 0x00230720 File Offset: 0x0022E920
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 604178, XrefRangeEnd = 604205, 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: 0x060088A6 RID: 34982 RVA: 0x00230794 File Offset: 0x0022E994
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 604205, XrefRangeEnd = 604207, 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: 0x060088A7 RID: 34983 RVA: 0x002307E4 File Offset: 0x0022E9E4
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 604207, XrefRangeEnd = 604214, 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: 0x060088A8 RID: 34984 RVA: 0x00230874 File Offset: 0x0022EA74
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 604214, XrefRangeEnd = 604215, 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: 0x060088A9 RID: 34985 RVA: 0x002308C0 File Offset: 0x0022EAC0
			// 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, 100673737);
				HitReactionVRIK.PositionOffset.NativeMethodInfoPtr_CrossFadeStart_Protected_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.PositionOffset>.NativeClassPtr, 100673738);
				HitReactionVRIK.PositionOffset.NativeMethodInfoPtr_OnApply_Protected_Virtual_Void_VRIK_Il2CppReferenceArray_1_AnimationCurve_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.PositionOffset>.NativeClassPtr, 100673739);
				HitReactionVRIK.PositionOffset.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.PositionOffset>.NativeClassPtr, 100673740);
			}

			// Token: 0x060088AA RID: 34986 RVA: 0x00230977 File Offset: 0x0022EB77
			public PositionOffset(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002E84 RID: 11908
			// (get) Token: 0x060088AB RID: 34987 RVA: 0x00230980 File Offset: 0x0022EB80
			// (set) Token: 0x060088AC RID: 34988 RVA: 0x002309A8 File Offset: 0x0022EBA8
			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: 0x17002E85 RID: 11909
			// (get) Token: 0x060088AD RID: 34989 RVA: 0x002309CC File Offset: 0x0022EBCC
			// (set) Token: 0x060088AE RID: 34990 RVA: 0x002309F4 File Offset: 0x0022EBF4
			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: 0x17002E86 RID: 11910
			// (get) Token: 0x060088AF RID: 34991 RVA: 0x00230A18 File Offset: 0x0022EC18
			// (set) Token: 0x060088B0 RID: 34992 RVA: 0x00230A4C File Offset: 0x0022EC4C
			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: 0x04005B2B RID: 23339
			private static readonly IntPtr NativeFieldInfoPtr_forceDirCurveIndex;

			// Token: 0x04005B2C RID: 23340
			private static readonly IntPtr NativeFieldInfoPtr_upDirCurveIndex;

			// Token: 0x04005B2D RID: 23341
			private static readonly IntPtr NativeFieldInfoPtr_offsetLinks;

			// Token: 0x04005B2E RID: 23342
			private static readonly IntPtr NativeMethodInfoPtr_GetLength_Protected_Virtual_Single_Il2CppReferenceArray_1_AnimationCurve_0;

			// Token: 0x04005B2F RID: 23343
			private static readonly IntPtr NativeMethodInfoPtr_CrossFadeStart_Protected_Virtual_Void_0;

			// Token: 0x04005B30 RID: 23344
			private static readonly IntPtr NativeMethodInfoPtr_OnApply_Protected_Virtual_Void_VRIK_Il2CppReferenceArray_1_AnimationCurve_Single_0;

			// Token: 0x04005B31 RID: 23345
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

			// Token: 0x02000485 RID: 1157
			[Serializable]
			public class PositionOffsetLink : Il2CppSystem.Object
			{
				// Token: 0x060088B1 RID: 34993 RVA: 0x00230A74 File Offset: 0x0022EC74
				[CallerCount(1)]
				[CachedScanResults(RefRangeStart = 604177, RefRangeEnd = 604178, XrefRangeStart = 604175, XrefRangeEnd = 604177, 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: 0x060088B2 RID: 34994 RVA: 0x00230AF4 File Offset: 0x0022ECF4
				[CallerCount(2)]
				[CachedScanResults(RefRangeStart = 604070, RefRangeEnd = 604072, XrefRangeStart = 604070, XrefRangeEnd = 604072, 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: 0x060088B3 RID: 34995 RVA: 0x00230B38 File Offset: 0x0022ED38
				[CallerCount(1642)]
				[CachedScanResults(RefRangeStart = 7417, RefRangeEnd = 9059, XrefRangeStart = 7417, XrefRangeEnd = 9059, 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: 0x060088B4 RID: 34996 RVA: 0x00230B84 File Offset: 0x0022ED84
				// 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, 100673741);
					HitReactionVRIK.PositionOffset.PositionOffsetLink.NativeMethodInfoPtr_CrossFadeStart_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.PositionOffset.PositionOffsetLink>.NativeClassPtr, 100673742);
					HitReactionVRIK.PositionOffset.PositionOffsetLink.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.PositionOffset.PositionOffsetLink>.NativeClassPtr, 100673743);
				}

				// Token: 0x060088B5 RID: 34997 RVA: 0x0000A688 File Offset: 0x00008888
				public PositionOffsetLink(IntPtr pointer)
					: base(pointer)
				{
				}

				// Token: 0x17002E87 RID: 11911
				// (get) Token: 0x060088B6 RID: 34998 RVA: 0x00230C3C File Offset: 0x0022EE3C
				// (set) Token: 0x060088B7 RID: 34999 RVA: 0x00230C64 File Offset: 0x0022EE64
				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: 0x17002E88 RID: 11912
				// (get) Token: 0x060088B8 RID: 35000 RVA: 0x00230C88 File Offset: 0x0022EE88
				// (set) Token: 0x060088B9 RID: 35001 RVA: 0x00230CB0 File Offset: 0x0022EEB0
				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: 0x17002E89 RID: 11913
				// (get) Token: 0x060088BA RID: 35002 RVA: 0x00230CD4 File Offset: 0x0022EED4
				// (set) Token: 0x060088BB RID: 35003 RVA: 0x00230CFC File Offset: 0x0022EEFC
				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: 0x17002E8A RID: 11914
				// (get) Token: 0x060088BC RID: 35004 RVA: 0x00230D20 File Offset: 0x0022EF20
				// (set) Token: 0x060088BD RID: 35005 RVA: 0x00230D48 File Offset: 0x0022EF48
				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: 0x04005B32 RID: 23346
				private static readonly IntPtr NativeFieldInfoPtr_positionOffset;

				// Token: 0x04005B33 RID: 23347
				private static readonly IntPtr NativeFieldInfoPtr_weight;

				// Token: 0x04005B34 RID: 23348
				private static readonly IntPtr NativeFieldInfoPtr_lastValue;

				// Token: 0x04005B35 RID: 23349
				private static readonly IntPtr NativeFieldInfoPtr_current;

				// Token: 0x04005B36 RID: 23350
				private static readonly IntPtr NativeMethodInfoPtr_Apply_Public_Void_VRIK_Vector3_Single_0;

				// Token: 0x04005B37 RID: 23351
				private static readonly IntPtr NativeMethodInfoPtr_CrossFadeStart_Public_Void_0;

				// Token: 0x04005B38 RID: 23352
				private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
			}
		}

		// Token: 0x02000486 RID: 1158
		[Serializable]
		public class RotationOffset : HitReactionVRIK.Offset
		{
			// Token: 0x060088BE RID: 35006 RVA: 0x00230D6C File Offset: 0x0022EF6C
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 604224, XrefRangeEnd = 604228, 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: 0x060088BF RID: 35007 RVA: 0x00230DE0 File Offset: 0x0022EFE0
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 604228, XrefRangeEnd = 604230, 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: 0x060088C0 RID: 35008 RVA: 0x00230E30 File Offset: 0x0022F030
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 604230, XrefRangeEnd = 604257, 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: 0x060088C1 RID: 35009 RVA: 0x00230EC0 File Offset: 0x0022F0C0
			[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: 0x060088C2 RID: 35010 RVA: 0x00230F0C File Offset: 0x0022F10C
			// 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, 100673744);
				HitReactionVRIK.RotationOffset.NativeMethodInfoPtr_CrossFadeStart_Protected_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.RotationOffset>.NativeClassPtr, 100673745);
				HitReactionVRIK.RotationOffset.NativeMethodInfoPtr_OnApply_Protected_Virtual_Void_VRIK_Il2CppReferenceArray_1_AnimationCurve_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.RotationOffset>.NativeClassPtr, 100673746);
				HitReactionVRIK.RotationOffset.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.RotationOffset>.NativeClassPtr, 100673747);
			}

			// Token: 0x060088C3 RID: 35011 RVA: 0x00230977 File Offset: 0x0022EB77
			public RotationOffset(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002E8B RID: 11915
			// (get) Token: 0x060088C4 RID: 35012 RVA: 0x00230FC4 File Offset: 0x0022F1C4
			// (set) Token: 0x060088C5 RID: 35013 RVA: 0x00230FEC File Offset: 0x0022F1EC
			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: 0x17002E8C RID: 11916
			// (get) Token: 0x060088C6 RID: 35014 RVA: 0x00231010 File Offset: 0x0022F210
			// (set) Token: 0x060088C7 RID: 35015 RVA: 0x00231044 File Offset: 0x0022F244
			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: 0x17002E8D RID: 11917
			// (get) Token: 0x060088C8 RID: 35016 RVA: 0x0023106C File Offset: 0x0022F26C
			// (set) Token: 0x060088C9 RID: 35017 RVA: 0x002310A0 File Offset: 0x0022F2A0
			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: 0x04005B39 RID: 23353
			private static readonly IntPtr NativeFieldInfoPtr_curveIndex;

			// Token: 0x04005B3A RID: 23354
			private static readonly IntPtr NativeFieldInfoPtr_offsetLinks;

			// Token: 0x04005B3B RID: 23355
			private static readonly IntPtr NativeFieldInfoPtr_rigidbody;

			// Token: 0x04005B3C RID: 23356
			private static readonly IntPtr NativeMethodInfoPtr_GetLength_Protected_Virtual_Single_Il2CppReferenceArray_1_AnimationCurve_0;

			// Token: 0x04005B3D RID: 23357
			private static readonly IntPtr NativeMethodInfoPtr_CrossFadeStart_Protected_Virtual_Void_0;

			// Token: 0x04005B3E RID: 23358
			private static readonly IntPtr NativeMethodInfoPtr_OnApply_Protected_Virtual_Void_VRIK_Il2CppReferenceArray_1_AnimationCurve_Single_0;

			// Token: 0x04005B3F RID: 23359
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

			// Token: 0x02000487 RID: 1159
			[Serializable]
			public class RotationOffsetLink : Il2CppSystem.Object
			{
				// Token: 0x060088CA RID: 35018 RVA: 0x002310C8 File Offset: 0x0022F2C8
				[CallerCount(1)]
				[CachedScanResults(RefRangeStart = 604219, RefRangeEnd = 604220, XrefRangeStart = 604215, XrefRangeEnd = 604219, 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: 0x060088CB RID: 35019 RVA: 0x00231148 File Offset: 0x0022F348
				[CallerCount(1)]
				[CachedScanResults(RefRangeStart = 604220, RefRangeEnd = 604221, XrefRangeStart = 604220, XrefRangeEnd = 604220, 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: 0x060088CC RID: 35020 RVA: 0x0023118C File Offset: 0x0022F38C
				[CallerCount(0)]
				[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 604221, XrefRangeEnd = 604224, 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: 0x060088CD RID: 35021 RVA: 0x002311D8 File Offset: 0x0022F3D8
				// 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, 100673748);
					HitReactionVRIK.RotationOffset.RotationOffsetLink.NativeMethodInfoPtr_CrossFadeStart_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.RotationOffset.RotationOffsetLink>.NativeClassPtr, 100673749);
					HitReactionVRIK.RotationOffset.RotationOffsetLink.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<HitReactionVRIK.RotationOffset.RotationOffsetLink>.NativeClassPtr, 100673750);
				}

				// Token: 0x060088CE RID: 35022 RVA: 0x0000A688 File Offset: 0x00008888
				public RotationOffsetLink(IntPtr pointer)
					: base(pointer)
				{
				}

				// Token: 0x17002E8E RID: 11918
				// (get) Token: 0x060088CF RID: 35023 RVA: 0x00231290 File Offset: 0x0022F490
				// (set) Token: 0x060088D0 RID: 35024 RVA: 0x002312B8 File Offset: 0x0022F4B8
				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: 0x17002E8F RID: 11919
				// (get) Token: 0x060088D1 RID: 35025 RVA: 0x002312DC File Offset: 0x0022F4DC
				// (set) Token: 0x060088D2 RID: 35026 RVA: 0x00231304 File Offset: 0x0022F504
				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: 0x17002E90 RID: 11920
				// (get) Token: 0x060088D3 RID: 35027 RVA: 0x00231328 File Offset: 0x0022F528
				// (set) Token: 0x060088D4 RID: 35028 RVA: 0x00231350 File Offset: 0x0022F550
				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: 0x17002E91 RID: 11921
				// (get) Token: 0x060088D5 RID: 35029 RVA: 0x00231374 File Offset: 0x0022F574
				// (set) Token: 0x060088D6 RID: 35030 RVA: 0x0023139C File Offset: 0x0022F59C
				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: 0x04005B40 RID: 23360
				private static readonly IntPtr NativeFieldInfoPtr_rotationOffset;

				// Token: 0x04005B41 RID: 23361
				private static readonly IntPtr NativeFieldInfoPtr_weight;

				// Token: 0x04005B42 RID: 23362
				private static readonly IntPtr NativeFieldInfoPtr_lastValue;

				// Token: 0x04005B43 RID: 23363
				private static readonly IntPtr NativeFieldInfoPtr_current;

				// Token: 0x04005B44 RID: 23364
				private static readonly IntPtr NativeMethodInfoPtr_Apply_Public_Void_VRIK_Quaternion_Single_0;

				// Token: 0x04005B45 RID: 23365
				private static readonly IntPtr NativeMethodInfoPtr_CrossFadeStart_Public_Void_0;

				// Token: 0x04005B46 RID: 23366
				private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
			}
		}
	}
}
