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

namespace RootMotion.FinalIK
{
	// Token: 0x02000492 RID: 1170
	public class Recoil : OffsetModifier
	{
		// Token: 0x17002EDA RID: 11994
		// (get) Token: 0x0600896C RID: 35180 RVA: 0x00233838 File Offset: 0x00231A38
		public unsafe bool isFinished
		{
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 604475, XrefRangeEnd = 604476, 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: 0x0600896D RID: 35181 RVA: 0x00233888 File Offset: 0x00231A88
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 604476, RefRangeEnd = 604478, XrefRangeStart = 604476, XrefRangeEnd = 604476, 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: 0x0600896E RID: 35182 RVA: 0x002338F0 File Offset: 0x00231AF0
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 604488, RefRangeEnd = 604489, XrefRangeStart = 604478, XrefRangeEnd = 604488, 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: 0x0600896F RID: 35183 RVA: 0x00233944 File Offset: 0x00231B44
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 604489, XrefRangeEnd = 604598, 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: 0x06008970 RID: 35184 RVA: 0x00233994 File Offset: 0x00231B94
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 604598, XrefRangeEnd = 604612, 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: 0x06008971 RID: 35185 RVA: 0x002339D8 File Offset: 0x00231BD8
		[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: 0x17002EDB RID: 11995
		// (get) Token: 0x06008972 RID: 35186 RVA: 0x00233A1C File Offset: 0x00231C1C
		public unsafe IKEffector primaryHandEffector
		{
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 604612, XrefRangeEnd = 604615, 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: 0x17002EDC RID: 11996
		// (get) Token: 0x06008973 RID: 35187 RVA: 0x00233A74 File Offset: 0x00231C74
		public unsafe IKEffector secondaryHandEffector
		{
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 604615, XrefRangeEnd = 604618, 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: 0x17002EDD RID: 11997
		// (get) Token: 0x06008974 RID: 35188 RVA: 0x00233ACC File Offset: 0x00231CCC
		public unsafe Transform primaryHand
		{
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 604618, XrefRangeEnd = 604621, 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: 0x17002EDE RID: 11998
		// (get) Token: 0x06008975 RID: 35189 RVA: 0x00233B24 File Offset: 0x00231D24
		public unsafe Transform secondaryHand
		{
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 604621, XrefRangeEnd = 604624, 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: 0x06008976 RID: 35190 RVA: 0x00233B7C File Offset: 0x00231D7C
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 604624, XrefRangeEnd = 604649, 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: 0x06008977 RID: 35191 RVA: 0x00233BCC File Offset: 0x00231DCC
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 604649, XrefRangeEnd = 604652, 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: 0x06008978 RID: 35192 RVA: 0x00233C18 File Offset: 0x00231E18
		// 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, 100673794);
			Recoil.NativeMethodInfoPtr_SetHandRotations_Public_Void_Quaternion_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Recoil>.NativeClassPtr, 100673795);
			Recoil.NativeMethodInfoPtr_Fire_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Recoil>.NativeClassPtr, 100673796);
			Recoil.NativeMethodInfoPtr_OnModifyOffset_Protected_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Recoil>.NativeClassPtr, 100673797);
			Recoil.NativeMethodInfoPtr_AfterFBBIK_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Recoil>.NativeClassPtr, 100673798);
			Recoil.NativeMethodInfoPtr_AfterAimIK_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Recoil>.NativeClassPtr, 100673799);
			Recoil.NativeMethodInfoPtr_get_primaryHandEffector_Private_get_IKEffector_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Recoil>.NativeClassPtr, 100673800);
			Recoil.NativeMethodInfoPtr_get_secondaryHandEffector_Private_get_IKEffector_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Recoil>.NativeClassPtr, 100673801);
			Recoil.NativeMethodInfoPtr_get_primaryHand_Private_get_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Recoil>.NativeClassPtr, 100673802);
			Recoil.NativeMethodInfoPtr_get_secondaryHand_Private_get_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Recoil>.NativeClassPtr, 100673803);
			Recoil.NativeMethodInfoPtr_OnDestroy_Protected_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Recoil>.NativeClassPtr, 100673804);
			Recoil.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Recoil>.NativeClassPtr, 100673805);
		}

		// Token: 0x06008979 RID: 35193 RVA: 0x001E5C80 File Offset: 0x001E3E80
		public Recoil(IntPtr pointer)
			: base(pointer)
		{
		}

		// Token: 0x17002EC3 RID: 11971
		// (get) Token: 0x0600897A RID: 35194 RVA: 0x00233F04 File Offset: 0x00232104
		// (set) Token: 0x0600897B RID: 35195 RVA: 0x00233F38 File Offset: 0x00232138
		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: 0x17002EC4 RID: 11972
		// (get) Token: 0x0600897C RID: 35196 RVA: 0x00233F60 File Offset: 0x00232160
		// (set) Token: 0x0600897D RID: 35197 RVA: 0x00233F88 File Offset: 0x00232188
		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: 0x17002EC5 RID: 11973
		// (get) Token: 0x0600897E RID: 35198 RVA: 0x00233FAC File Offset: 0x002321AC
		// (set) Token: 0x0600897F RID: 35199 RVA: 0x00233FD4 File Offset: 0x002321D4
		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: 0x17002EC6 RID: 11974
		// (get) Token: 0x06008980 RID: 35200 RVA: 0x00233FF8 File Offset: 0x002321F8
		// (set) Token: 0x06008981 RID: 35201 RVA: 0x00234020 File Offset: 0x00232220
		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: 0x17002EC7 RID: 11975
		// (get) Token: 0x06008982 RID: 35202 RVA: 0x00234044 File Offset: 0x00232244
		// (set) Token: 0x06008983 RID: 35203 RVA: 0x00234078 File Offset: 0x00232278
		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: 0x17002EC8 RID: 11976
		// (get) Token: 0x06008984 RID: 35204 RVA: 0x002340A0 File Offset: 0x002322A0
		// (set) Token: 0x06008985 RID: 35205 RVA: 0x002340C8 File Offset: 0x002322C8
		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: 0x17002EC9 RID: 11977
		// (get) Token: 0x06008986 RID: 35206 RVA: 0x002340EC File Offset: 0x002322EC
		// (set) Token: 0x06008987 RID: 35207 RVA: 0x00234114 File Offset: 0x00232314
		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: 0x17002ECA RID: 11978
		// (get) Token: 0x06008988 RID: 35208 RVA: 0x00234138 File Offset: 0x00232338
		// (set) Token: 0x06008989 RID: 35209 RVA: 0x00234160 File Offset: 0x00232360
		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: 0x17002ECB RID: 11979
		// (get) Token: 0x0600898A RID: 35210 RVA: 0x00234184 File Offset: 0x00232384
		// (set) Token: 0x0600898B RID: 35211 RVA: 0x002341AC File Offset: 0x002323AC
		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: 0x17002ECC RID: 11980
		// (get) Token: 0x0600898C RID: 35212 RVA: 0x002341D0 File Offset: 0x002323D0
		// (set) Token: 0x0600898D RID: 35213 RVA: 0x00234204 File Offset: 0x00232404
		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: 0x17002ECD RID: 11981
		// (get) Token: 0x0600898E RID: 35214 RVA: 0x0023422C File Offset: 0x0023242C
		// (set) Token: 0x0600898F RID: 35215 RVA: 0x00234254 File Offset: 0x00232454
		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: 0x17002ECE RID: 11982
		// (get) Token: 0x06008990 RID: 35216 RVA: 0x00234278 File Offset: 0x00232478
		// (set) Token: 0x06008991 RID: 35217 RVA: 0x002342A0 File Offset: 0x002324A0
		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: 0x17002ECF RID: 11983
		// (get) Token: 0x06008992 RID: 35218 RVA: 0x002342C4 File Offset: 0x002324C4
		// (set) Token: 0x06008993 RID: 35219 RVA: 0x002342EC File Offset: 0x002324EC
		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: 0x17002ED0 RID: 11984
		// (get) Token: 0x06008994 RID: 35220 RVA: 0x00234310 File Offset: 0x00232510
		// (set) Token: 0x06008995 RID: 35221 RVA: 0x00234338 File Offset: 0x00232538
		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: 0x17002ED1 RID: 11985
		// (get) Token: 0x06008996 RID: 35222 RVA: 0x0023435C File Offset: 0x0023255C
		// (set) Token: 0x06008997 RID: 35223 RVA: 0x00234384 File Offset: 0x00232584
		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: 0x17002ED2 RID: 11986
		// (get) Token: 0x06008998 RID: 35224 RVA: 0x002343A8 File Offset: 0x002325A8
		// (set) Token: 0x06008999 RID: 35225 RVA: 0x002343D0 File Offset: 0x002325D0
		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: 0x17002ED3 RID: 11987
		// (get) Token: 0x0600899A RID: 35226 RVA: 0x002343F4 File Offset: 0x002325F4
		// (set) Token: 0x0600899B RID: 35227 RVA: 0x0023441C File Offset: 0x0023261C
		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: 0x17002ED4 RID: 11988
		// (get) Token: 0x0600899C RID: 35228 RVA: 0x00234440 File Offset: 0x00232640
		// (set) Token: 0x0600899D RID: 35229 RVA: 0x00234468 File Offset: 0x00232668
		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: 0x17002ED5 RID: 11989
		// (get) Token: 0x0600899E RID: 35230 RVA: 0x0023448C File Offset: 0x0023268C
		// (set) Token: 0x0600899F RID: 35231 RVA: 0x002344B4 File Offset: 0x002326B4
		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: 0x17002ED6 RID: 11990
		// (get) Token: 0x060089A0 RID: 35232 RVA: 0x002344D8 File Offset: 0x002326D8
		// (set) Token: 0x060089A1 RID: 35233 RVA: 0x00234500 File Offset: 0x00232700
		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: 0x17002ED7 RID: 11991
		// (get) Token: 0x060089A2 RID: 35234 RVA: 0x00234524 File Offset: 0x00232724
		// (set) Token: 0x060089A3 RID: 35235 RVA: 0x0023454C File Offset: 0x0023274C
		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: 0x17002ED8 RID: 11992
		// (get) Token: 0x060089A4 RID: 35236 RVA: 0x00234570 File Offset: 0x00232770
		// (set) Token: 0x060089A5 RID: 35237 RVA: 0x00234598 File Offset: 0x00232798
		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: 0x17002ED9 RID: 11993
		// (get) Token: 0x060089A6 RID: 35238 RVA: 0x002345BC File Offset: 0x002327BC
		// (set) Token: 0x060089A7 RID: 35239 RVA: 0x002345E4 File Offset: 0x002327E4
		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: 0x04005B9D RID: 23453
		private static readonly IntPtr NativeFieldInfoPtr_aimIK;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		// Token: 0x04005BBB RID: 23483
		private static readonly IntPtr NativeMethodInfoPtr_get_secondaryHandEffector_Private_get_IKEffector_0;

		// Token: 0x04005BBC RID: 23484
		private static readonly IntPtr NativeMethodInfoPtr_get_primaryHand_Private_get_Transform_0;

		// Token: 0x04005BBD RID: 23485
		private static readonly IntPtr NativeMethodInfoPtr_get_secondaryHand_Private_get_Transform_0;

		// Token: 0x04005BBE RID: 23486
		private static readonly IntPtr NativeMethodInfoPtr_OnDestroy_Protected_Virtual_Void_0;

		// Token: 0x04005BBF RID: 23487
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

		// Token: 0x02000493 RID: 1171
		[Serializable]
		public class RecoilOffset : Il2CppSystem.Object
		{
			// Token: 0x060089A8 RID: 35240 RVA: 0x00234608 File Offset: 0x00232808
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 604466, RefRangeEnd = 604467, XrefRangeStart = 604465, XrefRangeEnd = 604466, 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: 0x060089A9 RID: 35241 RVA: 0x0023464C File Offset: 0x0023284C
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 604473, RefRangeEnd = 604474, XrefRangeStart = 604467, XrefRangeEnd = 604473, 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: 0x060089AA RID: 35242 RVA: 0x002346F4 File Offset: 0x002328F4
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 604474, XrefRangeEnd = 604475, 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: 0x060089AB RID: 35243 RVA: 0x00234740 File Offset: 0x00232940
			// 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, 100673806);
				Recoil.RecoilOffset.NativeMethodInfoPtr_Apply_Public_Void_IKSolverFullBodyBiped_Quaternion_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Recoil.RecoilOffset>.NativeClassPtr, 100673807);
				Recoil.RecoilOffset.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Recoil.RecoilOffset>.NativeClassPtr, 100673808);
			}

			// Token: 0x060089AC RID: 35244 RVA: 0x0000A688 File Offset: 0x00008888
			public RecoilOffset(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002EDF RID: 11999
			// (get) Token: 0x060089AD RID: 35245 RVA: 0x00234820 File Offset: 0x00232A20
			// (set) Token: 0x060089AE RID: 35246 RVA: 0x00234848 File Offset: 0x00232A48
			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: 0x17002EE0 RID: 12000
			// (get) Token: 0x060089AF RID: 35247 RVA: 0x0023486C File Offset: 0x00232A6C
			// (set) Token: 0x060089B0 RID: 35248 RVA: 0x00234894 File Offset: 0x00232A94
			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: 0x17002EE1 RID: 12001
			// (get) Token: 0x060089B1 RID: 35249 RVA: 0x002348B8 File Offset: 0x00232AB8
			// (set) Token: 0x060089B2 RID: 35250 RVA: 0x002348E0 File Offset: 0x00232AE0
			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: 0x17002EE2 RID: 12002
			// (get) Token: 0x060089B3 RID: 35251 RVA: 0x00234904 File Offset: 0x00232B04
			// (set) Token: 0x060089B4 RID: 35252 RVA: 0x00234938 File Offset: 0x00232B38
			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: 0x17002EE3 RID: 12003
			// (get) Token: 0x060089B5 RID: 35253 RVA: 0x00234960 File Offset: 0x00232B60
			// (set) Token: 0x060089B6 RID: 35254 RVA: 0x00234988 File Offset: 0x00232B88
			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: 0x17002EE4 RID: 12004
			// (get) Token: 0x060089B7 RID: 35255 RVA: 0x002349AC File Offset: 0x00232BAC
			// (set) Token: 0x060089B8 RID: 35256 RVA: 0x002349D4 File Offset: 0x00232BD4
			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: 0x04005BC0 RID: 23488
			private static readonly IntPtr NativeFieldInfoPtr_offset;

			// Token: 0x04005BC1 RID: 23489
			private static readonly IntPtr NativeFieldInfoPtr_additivity;

			// Token: 0x04005BC2 RID: 23490
			private static readonly IntPtr NativeFieldInfoPtr_maxAdditiveOffsetMag;

			// Token: 0x04005BC3 RID: 23491
			private static readonly IntPtr NativeFieldInfoPtr_effectorLinks;

			// Token: 0x04005BC4 RID: 23492
			private static readonly IntPtr NativeFieldInfoPtr_additiveOffset;

			// Token: 0x04005BC5 RID: 23493
			private static readonly IntPtr NativeFieldInfoPtr_lastOffset;

			// Token: 0x04005BC6 RID: 23494
			private static readonly IntPtr NativeMethodInfoPtr_Start_Public_Void_0;

			// Token: 0x04005BC7 RID: 23495
			private static readonly IntPtr NativeMethodInfoPtr_Apply_Public_Void_IKSolverFullBodyBiped_Quaternion_Single_Single_Single_0;

			// Token: 0x04005BC8 RID: 23496
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

			// Token: 0x02000494 RID: 1172
			[Serializable]
			public class EffectorLink : Il2CppSystem.Object
			{
				// Token: 0x060089B9 RID: 35257 RVA: 0x002349F8 File Offset: 0x00232BF8
				[CallerCount(1642)]
				[CachedScanResults(RefRangeStart = 7417, RefRangeEnd = 9059, XrefRangeStart = 7417, XrefRangeEnd = 9059, 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: 0x060089BA RID: 35258 RVA: 0x00234A44 File Offset: 0x00232C44
				// 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, 100673809);
				}

				// Token: 0x060089BB RID: 35259 RVA: 0x0000A688 File Offset: 0x00008888
				public EffectorLink(IntPtr pointer)
					: base(pointer)
				{
				}

				// Token: 0x17002EE5 RID: 12005
				// (get) Token: 0x060089BC RID: 35260 RVA: 0x00234AAC File Offset: 0x00232CAC
				// (set) Token: 0x060089BD RID: 35261 RVA: 0x00234AD4 File Offset: 0x00232CD4
				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: 0x17002EE6 RID: 12006
				// (get) Token: 0x060089BE RID: 35262 RVA: 0x00234AF8 File Offset: 0x00232CF8
				// (set) Token: 0x060089BF RID: 35263 RVA: 0x00234B20 File Offset: 0x00232D20
				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: 0x04005BC9 RID: 23497
				private static readonly IntPtr NativeFieldInfoPtr_effector;

				// Token: 0x04005BCA RID: 23498
				private static readonly IntPtr NativeFieldInfoPtr_weight;

				// Token: 0x04005BCB RID: 23499
				private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
			}
		}

		// Token: 0x02000495 RID: 1173
		[Serializable]
		public enum Handedness
		{
			// Token: 0x04005BCD RID: 23501
			Right,
			// Token: 0x04005BCE RID: 23502
			Left
		}
	}
}
