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

namespace RootMotion.FinalIK
{
	// Token: 0x0200049B RID: 1179
	public class Recoil : OffsetModifier
	{
		// Token: 0x17002F0C RID: 12044
		// (get) Token: 0x06008A1C RID: 35356 RVA: 0x0023643C File Offset: 0x0023463C
		public unsafe bool isFinished
		{
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 622206, XrefRangeEnd = 622207, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			get
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Recoil.NativeMethodInfoPtr_get_isFinished_Public_get_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}
		}

		// Token: 0x06008A1D RID: 35357 RVA: 0x0023648C File Offset: 0x0023468C
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 622207, RefRangeEnd = 622209, XrefRangeStart = 622207, XrefRangeEnd = 622207, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void SetHandRotations(Quaternion leftHandRotation, Quaternion rightHandRotation)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref leftHandRotation;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref rightHandRotation;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Recoil.NativeMethodInfoPtr_SetHandRotations_Public_Void_Quaternion_Quaternion_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06008A1E RID: 35358 RVA: 0x002364F4 File Offset: 0x002346F4
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 622219, RefRangeEnd = 622220, XrefRangeStart = 622209, XrefRangeEnd = 622219, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void Fire(float magnitude)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref magnitude;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Recoil.NativeMethodInfoPtr_Fire_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}
		}

		// Token: 0x06008A1F RID: 35359 RVA: 0x00236548 File Offset: 0x00234748
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 622220, XrefRangeEnd = 622329, 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), Recoil.NativeMethodInfoPtr_OnModifyOffset_Protected_Virtual_Void_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06008A20 RID: 35360 RVA: 0x00236598 File Offset: 0x00234798
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 622329, XrefRangeEnd = 622343, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void AfterFBBIK()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Recoil.NativeMethodInfoPtr_AfterFBBIK_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06008A21 RID: 35361 RVA: 0x002365DC File Offset: 0x002347DC
		[CallerCount(0)]
		public unsafe void AfterAimIK()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Recoil.NativeMethodInfoPtr_AfterAimIK_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x17002F0D RID: 12045
		// (get) Token: 0x06008A22 RID: 35362 RVA: 0x00236620 File Offset: 0x00234820
		public unsafe IKEffector primaryHandEffector
		{
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 622343, XrefRangeEnd = 622346, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			get
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Recoil.NativeMethodInfoPtr_get_primaryHandEffector_Private_get_IKEffector_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				IntPtr intPtr3 = intPtr;
				return (intPtr3 != 0) ? new IKEffector(intPtr3) : null;
			}
		}

		// Token: 0x17002F0E RID: 12046
		// (get) Token: 0x06008A23 RID: 35363 RVA: 0x00236678 File Offset: 0x00234878
		public unsafe IKEffector secondaryHandEffector
		{
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 622346, XrefRangeEnd = 622349, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			get
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Recoil.NativeMethodInfoPtr_get_secondaryHandEffector_Private_get_IKEffector_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				IntPtr intPtr3 = intPtr;
				return (intPtr3 != 0) ? new IKEffector(intPtr3) : null;
			}
		}

		// Token: 0x17002F0F RID: 12047
		// (get) Token: 0x06008A24 RID: 35364 RVA: 0x002366D0 File Offset: 0x002348D0
		public unsafe Transform primaryHand
		{
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 622349, XrefRangeEnd = 622352, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			get
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Recoil.NativeMethodInfoPtr_get_primaryHand_Private_get_Transform_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				IntPtr intPtr3 = intPtr;
				return (intPtr3 != 0) ? new Transform(intPtr3) : null;
			}
		}

		// Token: 0x17002F10 RID: 12048
		// (get) Token: 0x06008A25 RID: 35365 RVA: 0x00236728 File Offset: 0x00234928
		public unsafe Transform secondaryHand
		{
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 622352, XrefRangeEnd = 622355, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			get
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Recoil.NativeMethodInfoPtr_get_secondaryHand_Private_get_Transform_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				IntPtr intPtr3 = intPtr;
				return (intPtr3 != 0) ? new Transform(intPtr3) : null;
			}
		}

		// Token: 0x06008A26 RID: 35366 RVA: 0x00236780 File Offset: 0x00234980
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 622355, XrefRangeEnd = 622380, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe override void OnDestroy()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), Recoil.NativeMethodInfoPtr_OnDestroy_Protected_Virtual_Void_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

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

		// Token: 0x06008A28 RID: 35368 RVA: 0x0023681C File Offset: 0x00234A1C
		// Note: this type is marked as 'beforefieldinit'.
		static Recoil()
		{
			Il2CppClassPointerStore<Recoil>.NativeClassPtr = IL2CPP.GetIl2CppClass("Assembly-CSharp.dll", "RootMotion.FinalIK", "Recoil");
			IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<Recoil>.NativeClassPtr);
			Recoil.NativeFieldInfoPtr_aimIK = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Recoil>.NativeClassPtr, "aimIK");
			Recoil.NativeFieldInfoPtr_aimIKSolvedLast = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Recoil>.NativeClassPtr, "aimIKSolvedLast");
			Recoil.NativeFieldInfoPtr_handedness = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Recoil>.NativeClassPtr, "handedness");
			Recoil.NativeFieldInfoPtr_twoHanded = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Recoil>.NativeClassPtr, "twoHanded");
			Recoil.NativeFieldInfoPtr_recoilWeight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Recoil>.NativeClassPtr, "recoilWeight");
			Recoil.NativeFieldInfoPtr_magnitudeRandom = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Recoil>.NativeClassPtr, "magnitudeRandom");
			Recoil.NativeFieldInfoPtr_rotationRandom = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Recoil>.NativeClassPtr, "rotationRandom");
			Recoil.NativeFieldInfoPtr_handRotationOffset = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Recoil>.NativeClassPtr, "handRotationOffset");
			Recoil.NativeFieldInfoPtr_blendTime = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Recoil>.NativeClassPtr, "blendTime");
			Recoil.NativeFieldInfoPtr_offsets = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Recoil>.NativeClassPtr, "offsets");
			Recoil.NativeFieldInfoPtr_rotationOffset = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Recoil>.NativeClassPtr, "rotationOffset");
			Recoil.NativeFieldInfoPtr_magnitudeMlp = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Recoil>.NativeClassPtr, "magnitudeMlp");
			Recoil.NativeFieldInfoPtr_endTime = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Recoil>.NativeClassPtr, "endTime");
			Recoil.NativeFieldInfoPtr_handRotation = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Recoil>.NativeClassPtr, "handRotation");
			Recoil.NativeFieldInfoPtr_secondaryHandRelativeRotation = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Recoil>.NativeClassPtr, "secondaryHandRelativeRotation");
			Recoil.NativeFieldInfoPtr_randomRotation = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Recoil>.NativeClassPtr, "randomRotation");
			Recoil.NativeFieldInfoPtr_length = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Recoil>.NativeClassPtr, "length");
			Recoil.NativeFieldInfoPtr_initiated = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Recoil>.NativeClassPtr, "initiated");
			Recoil.NativeFieldInfoPtr_blendWeight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Recoil>.NativeClassPtr, "blendWeight");
			Recoil.NativeFieldInfoPtr_w = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Recoil>.NativeClassPtr, "w");
			Recoil.NativeFieldInfoPtr_primaryHandRotation = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Recoil>.NativeClassPtr, "primaryHandRotation");
			Recoil.NativeFieldInfoPtr_handRotationsSet = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Recoil>.NativeClassPtr, "handRotationsSet");
			Recoil.NativeFieldInfoPtr_aimIKAxis = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Recoil>.NativeClassPtr, "aimIKAxis");
			Recoil.NativeMethodInfoPtr_get_isFinished_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Recoil>.NativeClassPtr, 100673844);
			Recoil.NativeMethodInfoPtr_SetHandRotations_Public_Void_Quaternion_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Recoil>.NativeClassPtr, 100673845);
			Recoil.NativeMethodInfoPtr_Fire_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Recoil>.NativeClassPtr, 100673846);
			Recoil.NativeMethodInfoPtr_OnModifyOffset_Protected_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Recoil>.NativeClassPtr, 100673847);
			Recoil.NativeMethodInfoPtr_AfterFBBIK_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Recoil>.NativeClassPtr, 100673848);
			Recoil.NativeMethodInfoPtr_AfterAimIK_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Recoil>.NativeClassPtr, 100673849);
			Recoil.NativeMethodInfoPtr_get_primaryHandEffector_Private_get_IKEffector_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Recoil>.NativeClassPtr, 100673850);
			Recoil.NativeMethodInfoPtr_get_secondaryHandEffector_Private_get_IKEffector_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Recoil>.NativeClassPtr, 100673851);
			Recoil.NativeMethodInfoPtr_get_primaryHand_Private_get_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Recoil>.NativeClassPtr, 100673852);
			Recoil.NativeMethodInfoPtr_get_secondaryHand_Private_get_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Recoil>.NativeClassPtr, 100673853);
			Recoil.NativeMethodInfoPtr_OnDestroy_Protected_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Recoil>.NativeClassPtr, 100673854);
			Recoil.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Recoil>.NativeClassPtr, 100673855);
		}

		// Token: 0x06008A29 RID: 35369 RVA: 0x001E8884 File Offset: 0x001E6A84
		public Recoil(IntPtr pointer)
			: base(pointer)
		{
		}

		// Token: 0x17002EF5 RID: 12021
		// (get) Token: 0x06008A2A RID: 35370 RVA: 0x00236B08 File Offset: 0x00234D08
		// (set) Token: 0x06008A2B RID: 35371 RVA: 0x00236B3C File Offset: 0x00234D3C
		public unsafe AimIK aimIK
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_aimIK);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new AimIK(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_aimIK), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002EF6 RID: 12022
		// (get) Token: 0x06008A2C RID: 35372 RVA: 0x00236B64 File Offset: 0x00234D64
		// (set) Token: 0x06008A2D RID: 35373 RVA: 0x00236B8C File Offset: 0x00234D8C
		public unsafe bool aimIKSolvedLast
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_aimIKSolvedLast);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_aimIKSolvedLast)) = value;
			}
		}

		// Token: 0x17002EF7 RID: 12023
		// (get) Token: 0x06008A2E RID: 35374 RVA: 0x00236BB0 File Offset: 0x00234DB0
		// (set) Token: 0x06008A2F RID: 35375 RVA: 0x00236BD8 File Offset: 0x00234DD8
		public unsafe Recoil.Handedness handedness
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_handedness);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_handedness)) = value;
			}
		}

		// Token: 0x17002EF8 RID: 12024
		// (get) Token: 0x06008A30 RID: 35376 RVA: 0x00236BFC File Offset: 0x00234DFC
		// (set) Token: 0x06008A31 RID: 35377 RVA: 0x00236C24 File Offset: 0x00234E24
		public unsafe bool twoHanded
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_twoHanded);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_twoHanded)) = value;
			}
		}

		// Token: 0x17002EF9 RID: 12025
		// (get) Token: 0x06008A32 RID: 35378 RVA: 0x00236C48 File Offset: 0x00234E48
		// (set) Token: 0x06008A33 RID: 35379 RVA: 0x00236C7C File Offset: 0x00234E7C
		public unsafe AnimationCurve recoilWeight
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_recoilWeight);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new AnimationCurve(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_recoilWeight), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002EFA RID: 12026
		// (get) Token: 0x06008A34 RID: 35380 RVA: 0x00236CA4 File Offset: 0x00234EA4
		// (set) Token: 0x06008A35 RID: 35381 RVA: 0x00236CCC File Offset: 0x00234ECC
		public unsafe float magnitudeRandom
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_magnitudeRandom);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_magnitudeRandom)) = value;
			}
		}

		// Token: 0x17002EFB RID: 12027
		// (get) Token: 0x06008A36 RID: 35382 RVA: 0x00236CF0 File Offset: 0x00234EF0
		// (set) Token: 0x06008A37 RID: 35383 RVA: 0x00236D18 File Offset: 0x00234F18
		public unsafe Vector3 rotationRandom
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_rotationRandom);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_rotationRandom)) = value;
			}
		}

		// Token: 0x17002EFC RID: 12028
		// (get) Token: 0x06008A38 RID: 35384 RVA: 0x00236D3C File Offset: 0x00234F3C
		// (set) Token: 0x06008A39 RID: 35385 RVA: 0x00236D64 File Offset: 0x00234F64
		public unsafe Vector3 handRotationOffset
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_handRotationOffset);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_handRotationOffset)) = value;
			}
		}

		// Token: 0x17002EFD RID: 12029
		// (get) Token: 0x06008A3A RID: 35386 RVA: 0x00236D88 File Offset: 0x00234F88
		// (set) Token: 0x06008A3B RID: 35387 RVA: 0x00236DB0 File Offset: 0x00234FB0
		public unsafe float blendTime
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_blendTime);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_blendTime)) = value;
			}
		}

		// Token: 0x17002EFE RID: 12030
		// (get) Token: 0x06008A3C RID: 35388 RVA: 0x00236DD4 File Offset: 0x00234FD4
		// (set) Token: 0x06008A3D RID: 35389 RVA: 0x00236E08 File Offset: 0x00235008
		public unsafe Il2CppReferenceArray<Recoil.RecoilOffset> offsets
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_offsets);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new Il2CppReferenceArray<Recoil.RecoilOffset>(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_offsets), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002EFF RID: 12031
		// (get) Token: 0x06008A3E RID: 35390 RVA: 0x00236E30 File Offset: 0x00235030
		// (set) Token: 0x06008A3F RID: 35391 RVA: 0x00236E58 File Offset: 0x00235058
		public unsafe Quaternion rotationOffset
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_rotationOffset);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_rotationOffset)) = value;
			}
		}

		// Token: 0x17002F00 RID: 12032
		// (get) Token: 0x06008A40 RID: 35392 RVA: 0x00236E7C File Offset: 0x0023507C
		// (set) Token: 0x06008A41 RID: 35393 RVA: 0x00236EA4 File Offset: 0x002350A4
		public unsafe float magnitudeMlp
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_magnitudeMlp);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_magnitudeMlp)) = value;
			}
		}

		// Token: 0x17002F01 RID: 12033
		// (get) Token: 0x06008A42 RID: 35394 RVA: 0x00236EC8 File Offset: 0x002350C8
		// (set) Token: 0x06008A43 RID: 35395 RVA: 0x00236EF0 File Offset: 0x002350F0
		public unsafe float endTime
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_endTime);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_endTime)) = value;
			}
		}

		// Token: 0x17002F02 RID: 12034
		// (get) Token: 0x06008A44 RID: 35396 RVA: 0x00236F14 File Offset: 0x00235114
		// (set) Token: 0x06008A45 RID: 35397 RVA: 0x00236F3C File Offset: 0x0023513C
		public unsafe Quaternion handRotation
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_handRotation);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_handRotation)) = value;
			}
		}

		// Token: 0x17002F03 RID: 12035
		// (get) Token: 0x06008A46 RID: 35398 RVA: 0x00236F60 File Offset: 0x00235160
		// (set) Token: 0x06008A47 RID: 35399 RVA: 0x00236F88 File Offset: 0x00235188
		public unsafe Quaternion secondaryHandRelativeRotation
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_secondaryHandRelativeRotation);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_secondaryHandRelativeRotation)) = value;
			}
		}

		// Token: 0x17002F04 RID: 12036
		// (get) Token: 0x06008A48 RID: 35400 RVA: 0x00236FAC File Offset: 0x002351AC
		// (set) Token: 0x06008A49 RID: 35401 RVA: 0x00236FD4 File Offset: 0x002351D4
		public unsafe Quaternion randomRotation
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_randomRotation);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_randomRotation)) = value;
			}
		}

		// Token: 0x17002F05 RID: 12037
		// (get) Token: 0x06008A4A RID: 35402 RVA: 0x00236FF8 File Offset: 0x002351F8
		// (set) Token: 0x06008A4B RID: 35403 RVA: 0x00237020 File Offset: 0x00235220
		public unsafe float length
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_length);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_length)) = value;
			}
		}

		// Token: 0x17002F06 RID: 12038
		// (get) Token: 0x06008A4C RID: 35404 RVA: 0x00237044 File Offset: 0x00235244
		// (set) Token: 0x06008A4D RID: 35405 RVA: 0x0023706C File Offset: 0x0023526C
		public unsafe bool initiated
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_initiated);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_initiated)) = value;
			}
		}

		// Token: 0x17002F07 RID: 12039
		// (get) Token: 0x06008A4E RID: 35406 RVA: 0x00237090 File Offset: 0x00235290
		// (set) Token: 0x06008A4F RID: 35407 RVA: 0x002370B8 File Offset: 0x002352B8
		public unsafe float blendWeight
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_blendWeight);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_blendWeight)) = value;
			}
		}

		// Token: 0x17002F08 RID: 12040
		// (get) Token: 0x06008A50 RID: 35408 RVA: 0x002370DC File Offset: 0x002352DC
		// (set) Token: 0x06008A51 RID: 35409 RVA: 0x00237104 File Offset: 0x00235304
		public unsafe float w
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_w);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_w)) = value;
			}
		}

		// Token: 0x17002F09 RID: 12041
		// (get) Token: 0x06008A52 RID: 35410 RVA: 0x00237128 File Offset: 0x00235328
		// (set) Token: 0x06008A53 RID: 35411 RVA: 0x00237150 File Offset: 0x00235350
		public unsafe Quaternion primaryHandRotation
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_primaryHandRotation);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_primaryHandRotation)) = value;
			}
		}

		// Token: 0x17002F0A RID: 12042
		// (get) Token: 0x06008A54 RID: 35412 RVA: 0x00237174 File Offset: 0x00235374
		// (set) Token: 0x06008A55 RID: 35413 RVA: 0x0023719C File Offset: 0x0023539C
		public unsafe bool handRotationsSet
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_handRotationsSet);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_handRotationsSet)) = value;
			}
		}

		// Token: 0x17002F0B RID: 12043
		// (get) Token: 0x06008A56 RID: 35414 RVA: 0x002371C0 File Offset: 0x002353C0
		// (set) Token: 0x06008A57 RID: 35415 RVA: 0x002371E8 File Offset: 0x002353E8
		public unsafe Vector3 aimIKAxis
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_aimIKAxis);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.NativeFieldInfoPtr_aimIKAxis)) = value;
			}
		}

		// Token: 0x04005C11 RID: 23569
		private static readonly IntPtr NativeFieldInfoPtr_aimIK;

		// Token: 0x04005C12 RID: 23570
		private static readonly IntPtr NativeFieldInfoPtr_aimIKSolvedLast;

		// Token: 0x04005C13 RID: 23571
		private static readonly IntPtr NativeFieldInfoPtr_handedness;

		// Token: 0x04005C14 RID: 23572
		private static readonly IntPtr NativeFieldInfoPtr_twoHanded;

		// Token: 0x04005C15 RID: 23573
		private static readonly IntPtr NativeFieldInfoPtr_recoilWeight;

		// Token: 0x04005C16 RID: 23574
		private static readonly IntPtr NativeFieldInfoPtr_magnitudeRandom;

		// Token: 0x04005C17 RID: 23575
		private static readonly IntPtr NativeFieldInfoPtr_rotationRandom;

		// Token: 0x04005C18 RID: 23576
		private static readonly IntPtr NativeFieldInfoPtr_handRotationOffset;

		// Token: 0x04005C19 RID: 23577
		private static readonly IntPtr NativeFieldInfoPtr_blendTime;

		// Token: 0x04005C1A RID: 23578
		private static readonly IntPtr NativeFieldInfoPtr_offsets;

		// Token: 0x04005C1B RID: 23579
		private static readonly IntPtr NativeFieldInfoPtr_rotationOffset;

		// Token: 0x04005C1C RID: 23580
		private static readonly IntPtr NativeFieldInfoPtr_magnitudeMlp;

		// Token: 0x04005C1D RID: 23581
		private static readonly IntPtr NativeFieldInfoPtr_endTime;

		// Token: 0x04005C1E RID: 23582
		private static readonly IntPtr NativeFieldInfoPtr_handRotation;

		// Token: 0x04005C1F RID: 23583
		private static readonly IntPtr NativeFieldInfoPtr_secondaryHandRelativeRotation;

		// Token: 0x04005C20 RID: 23584
		private static readonly IntPtr NativeFieldInfoPtr_randomRotation;

		// Token: 0x04005C21 RID: 23585
		private static readonly IntPtr NativeFieldInfoPtr_length;

		// Token: 0x04005C22 RID: 23586
		private static readonly IntPtr NativeFieldInfoPtr_initiated;

		// Token: 0x04005C23 RID: 23587
		private static readonly IntPtr NativeFieldInfoPtr_blendWeight;

		// Token: 0x04005C24 RID: 23588
		private static readonly IntPtr NativeFieldInfoPtr_w;

		// Token: 0x04005C25 RID: 23589
		private static readonly IntPtr NativeFieldInfoPtr_primaryHandRotation;

		// Token: 0x04005C26 RID: 23590
		private static readonly IntPtr NativeFieldInfoPtr_handRotationsSet;

		// Token: 0x04005C27 RID: 23591
		private static readonly IntPtr NativeFieldInfoPtr_aimIKAxis;

		// Token: 0x04005C28 RID: 23592
		private static readonly IntPtr NativeMethodInfoPtr_get_isFinished_Public_get_Boolean_0;

		// Token: 0x04005C29 RID: 23593
		private static readonly IntPtr NativeMethodInfoPtr_SetHandRotations_Public_Void_Quaternion_Quaternion_0;

		// Token: 0x04005C2A RID: 23594
		private static readonly IntPtr NativeMethodInfoPtr_Fire_Public_Void_Single_0;

		// Token: 0x04005C2B RID: 23595
		private static readonly IntPtr NativeMethodInfoPtr_OnModifyOffset_Protected_Virtual_Void_0;

		// Token: 0x04005C2C RID: 23596
		private static readonly IntPtr NativeMethodInfoPtr_AfterFBBIK_Private_Void_0;

		// Token: 0x04005C2D RID: 23597
		private static readonly IntPtr NativeMethodInfoPtr_AfterAimIK_Private_Void_0;

		// Token: 0x04005C2E RID: 23598
		private static readonly IntPtr NativeMethodInfoPtr_get_primaryHandEffector_Private_get_IKEffector_0;

		// Token: 0x04005C2F RID: 23599
		private static readonly IntPtr NativeMethodInfoPtr_get_secondaryHandEffector_Private_get_IKEffector_0;

		// Token: 0x04005C30 RID: 23600
		private static readonly IntPtr NativeMethodInfoPtr_get_primaryHand_Private_get_Transform_0;

		// Token: 0x04005C31 RID: 23601
		private static readonly IntPtr NativeMethodInfoPtr_get_secondaryHand_Private_get_Transform_0;

		// Token: 0x04005C32 RID: 23602
		private static readonly IntPtr NativeMethodInfoPtr_OnDestroy_Protected_Virtual_Void_0;

		// Token: 0x04005C33 RID: 23603
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

		// Token: 0x0200049C RID: 1180
		[Serializable]
		public class RecoilOffset : Il2CppSystem.Object
		{
			// Token: 0x06008A58 RID: 35416 RVA: 0x0023720C File Offset: 0x0023540C
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 622197, RefRangeEnd = 622198, XrefRangeStart = 622196, XrefRangeEnd = 622197, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void Start()
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Recoil.RecoilOffset.NativeMethodInfoPtr_Start_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008A59 RID: 35417 RVA: 0x00237250 File Offset: 0x00235450
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 622204, RefRangeEnd = 622205, XrefRangeStart = 622198, XrefRangeEnd = 622204, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void Apply(IKSolverFullBodyBiped solver, Quaternion rotation, float masterWeight, float length, float timeLeft)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)5) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(solver);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref rotation;
				ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref masterWeight;
				ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref length;
				ptr[checked(unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref timeLeft;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Recoil.RecoilOffset.NativeMethodInfoPtr_Apply_Public_Void_IKSolverFullBodyBiped_Quaternion_Single_Single_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008A5A RID: 35418 RVA: 0x002372F8 File Offset: 0x002354F8
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 622205, XrefRangeEnd = 622206, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe RecoilOffset()
				: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<Recoil.RecoilOffset>.NativeClassPtr))
			{
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Recoil.RecoilOffset.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008A5B RID: 35419 RVA: 0x00237344 File Offset: 0x00235544
			// Note: this type is marked as 'beforefieldinit'.
			static RecoilOffset()
			{
				Il2CppClassPointerStore<Recoil.RecoilOffset>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<Recoil>.NativeClassPtr, "RecoilOffset");
				IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<Recoil.RecoilOffset>.NativeClassPtr);
				Recoil.RecoilOffset.NativeFieldInfoPtr_offset = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Recoil.RecoilOffset>.NativeClassPtr, "offset");
				Recoil.RecoilOffset.NativeFieldInfoPtr_additivity = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Recoil.RecoilOffset>.NativeClassPtr, "additivity");
				Recoil.RecoilOffset.NativeFieldInfoPtr_maxAdditiveOffsetMag = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Recoil.RecoilOffset>.NativeClassPtr, "maxAdditiveOffsetMag");
				Recoil.RecoilOffset.NativeFieldInfoPtr_effectorLinks = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Recoil.RecoilOffset>.NativeClassPtr, "effectorLinks");
				Recoil.RecoilOffset.NativeFieldInfoPtr_additiveOffset = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Recoil.RecoilOffset>.NativeClassPtr, "additiveOffset");
				Recoil.RecoilOffset.NativeFieldInfoPtr_lastOffset = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Recoil.RecoilOffset>.NativeClassPtr, "lastOffset");
				Recoil.RecoilOffset.NativeMethodInfoPtr_Start_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Recoil.RecoilOffset>.NativeClassPtr, 100673856);
				Recoil.RecoilOffset.NativeMethodInfoPtr_Apply_Public_Void_IKSolverFullBodyBiped_Quaternion_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Recoil.RecoilOffset>.NativeClassPtr, 100673857);
				Recoil.RecoilOffset.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Recoil.RecoilOffset>.NativeClassPtr, 100673858);
			}

			// Token: 0x06008A5C RID: 35420 RVA: 0x0000A74C File Offset: 0x0000894C
			public RecoilOffset(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002F11 RID: 12049
			// (get) Token: 0x06008A5D RID: 35421 RVA: 0x00237424 File Offset: 0x00235624
			// (set) Token: 0x06008A5E RID: 35422 RVA: 0x0023744C File Offset: 0x0023564C
			public unsafe Vector3 offset
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.RecoilOffset.NativeFieldInfoPtr_offset);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.RecoilOffset.NativeFieldInfoPtr_offset)) = value;
				}
			}

			// Token: 0x17002F12 RID: 12050
			// (get) Token: 0x06008A5F RID: 35423 RVA: 0x00237470 File Offset: 0x00235670
			// (set) Token: 0x06008A60 RID: 35424 RVA: 0x00237498 File Offset: 0x00235698
			public unsafe float additivity
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.RecoilOffset.NativeFieldInfoPtr_additivity);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.RecoilOffset.NativeFieldInfoPtr_additivity)) = value;
				}
			}

			// Token: 0x17002F13 RID: 12051
			// (get) Token: 0x06008A61 RID: 35425 RVA: 0x002374BC File Offset: 0x002356BC
			// (set) Token: 0x06008A62 RID: 35426 RVA: 0x002374E4 File Offset: 0x002356E4
			public unsafe float maxAdditiveOffsetMag
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.RecoilOffset.NativeFieldInfoPtr_maxAdditiveOffsetMag);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.RecoilOffset.NativeFieldInfoPtr_maxAdditiveOffsetMag)) = value;
				}
			}

			// Token: 0x17002F14 RID: 12052
			// (get) Token: 0x06008A63 RID: 35427 RVA: 0x00237508 File Offset: 0x00235708
			// (set) Token: 0x06008A64 RID: 35428 RVA: 0x0023753C File Offset: 0x0023573C
			public unsafe Il2CppReferenceArray<Recoil.RecoilOffset.EffectorLink> effectorLinks
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.RecoilOffset.NativeFieldInfoPtr_effectorLinks);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new Il2CppReferenceArray<Recoil.RecoilOffset.EffectorLink>(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.RecoilOffset.NativeFieldInfoPtr_effectorLinks), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x17002F15 RID: 12053
			// (get) Token: 0x06008A65 RID: 35429 RVA: 0x00237564 File Offset: 0x00235764
			// (set) Token: 0x06008A66 RID: 35430 RVA: 0x0023758C File Offset: 0x0023578C
			public unsafe Vector3 additiveOffset
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.RecoilOffset.NativeFieldInfoPtr_additiveOffset);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.RecoilOffset.NativeFieldInfoPtr_additiveOffset)) = value;
				}
			}

			// Token: 0x17002F16 RID: 12054
			// (get) Token: 0x06008A67 RID: 35431 RVA: 0x002375B0 File Offset: 0x002357B0
			// (set) Token: 0x06008A68 RID: 35432 RVA: 0x002375D8 File Offset: 0x002357D8
			public unsafe Vector3 lastOffset
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.RecoilOffset.NativeFieldInfoPtr_lastOffset);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.RecoilOffset.NativeFieldInfoPtr_lastOffset)) = value;
				}
			}

			// Token: 0x04005C34 RID: 23604
			private static readonly IntPtr NativeFieldInfoPtr_offset;

			// Token: 0x04005C35 RID: 23605
			private static readonly IntPtr NativeFieldInfoPtr_additivity;

			// Token: 0x04005C36 RID: 23606
			private static readonly IntPtr NativeFieldInfoPtr_maxAdditiveOffsetMag;

			// Token: 0x04005C37 RID: 23607
			private static readonly IntPtr NativeFieldInfoPtr_effectorLinks;

			// Token: 0x04005C38 RID: 23608
			private static readonly IntPtr NativeFieldInfoPtr_additiveOffset;

			// Token: 0x04005C39 RID: 23609
			private static readonly IntPtr NativeFieldInfoPtr_lastOffset;

			// Token: 0x04005C3A RID: 23610
			private static readonly IntPtr NativeMethodInfoPtr_Start_Public_Void_0;

			// Token: 0x04005C3B RID: 23611
			private static readonly IntPtr NativeMethodInfoPtr_Apply_Public_Void_IKSolverFullBodyBiped_Quaternion_Single_Single_Single_0;

			// Token: 0x04005C3C RID: 23612
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

			// Token: 0x0200049D RID: 1181
			[Serializable]
			public class EffectorLink : Il2CppSystem.Object
			{
				// Token: 0x06008A69 RID: 35433 RVA: 0x002375FC File Offset: 0x002357FC
				[CallerCount(1659)]
				[CachedScanResults(RefRangeStart = 7639, RefRangeEnd = 9298, XrefRangeStart = 7639, XrefRangeEnd = 9298, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
				public unsafe EffectorLink()
					: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<Recoil.RecoilOffset.EffectorLink>.NativeClassPtr))
				{
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Recoil.RecoilOffset.EffectorLink.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				}

				// Token: 0x06008A6A RID: 35434 RVA: 0x00237648 File Offset: 0x00235848
				// Note: this type is marked as 'beforefieldinit'.
				static EffectorLink()
				{
					Il2CppClassPointerStore<Recoil.RecoilOffset.EffectorLink>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<Recoil.RecoilOffset>.NativeClassPtr, "EffectorLink");
					IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<Recoil.RecoilOffset.EffectorLink>.NativeClassPtr);
					Recoil.RecoilOffset.EffectorLink.NativeFieldInfoPtr_effector = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Recoil.RecoilOffset.EffectorLink>.NativeClassPtr, "effector");
					Recoil.RecoilOffset.EffectorLink.NativeFieldInfoPtr_weight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<Recoil.RecoilOffset.EffectorLink>.NativeClassPtr, "weight");
					Recoil.RecoilOffset.EffectorLink.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Recoil.RecoilOffset.EffectorLink>.NativeClassPtr, 100673859);
				}

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

				// Token: 0x17002F17 RID: 12055
				// (get) Token: 0x06008A6C RID: 35436 RVA: 0x002376B0 File Offset: 0x002358B0
				// (set) Token: 0x06008A6D RID: 35437 RVA: 0x002376D8 File Offset: 0x002358D8
				public unsafe FullBodyBipedEffector effector
				{
					get
					{
						IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.RecoilOffset.EffectorLink.NativeFieldInfoPtr_effector);
						return *intPtr;
					}
					set
					{
						*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.RecoilOffset.EffectorLink.NativeFieldInfoPtr_effector)) = value;
					}
				}

				// Token: 0x17002F18 RID: 12056
				// (get) Token: 0x06008A6E RID: 35438 RVA: 0x002376FC File Offset: 0x002358FC
				// (set) Token: 0x06008A6F RID: 35439 RVA: 0x00237724 File Offset: 0x00235924
				public unsafe float weight
				{
					get
					{
						IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.RecoilOffset.EffectorLink.NativeFieldInfoPtr_weight);
						return *intPtr;
					}
					set
					{
						*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(Recoil.RecoilOffset.EffectorLink.NativeFieldInfoPtr_weight)) = value;
					}
				}

				// Token: 0x04005C3D RID: 23613
				private static readonly IntPtr NativeFieldInfoPtr_effector;

				// Token: 0x04005C3E RID: 23614
				private static readonly IntPtr NativeFieldInfoPtr_weight;

				// Token: 0x04005C3F RID: 23615
				private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
			}
		}

		// Token: 0x0200049E RID: 1182
		[Serializable]
		public enum Handedness
		{
			// Token: 0x04005C41 RID: 23617
			Right,
			// Token: 0x04005C42 RID: 23618
			Left
		}
	}
}