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

namespace RootMotion.FinalIK
{
	// Token: 0x020004EA RID: 1258
	public class Recoil : OffsetModifier
	{
		// Token: 0x17003175 RID: 12661
		// (get) Token: 0x060091BF RID: 37311 RVA: 0x00256574 File Offset: 0x00254774
		public unsafe bool isFinished
		{
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 636785, XrefRangeEnd = 636786, 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: 0x060091C0 RID: 37312 RVA: 0x002565C4 File Offset: 0x002547C4
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 636786, RefRangeEnd = 636788, XrefRangeStart = 636786, XrefRangeEnd = 636786, 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: 0x060091C1 RID: 37313 RVA: 0x0025662C File Offset: 0x0025482C
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 636798, RefRangeEnd = 636799, XrefRangeStart = 636788, XrefRangeEnd = 636798, 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: 0x060091C2 RID: 37314 RVA: 0x00256680 File Offset: 0x00254880
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 636799, XrefRangeEnd = 636908, 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: 0x060091C3 RID: 37315 RVA: 0x002566D0 File Offset: 0x002548D0
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 636908, XrefRangeEnd = 636922, 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: 0x060091C4 RID: 37316 RVA: 0x00256714 File Offset: 0x00254914
		[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: 0x17003176 RID: 12662
		// (get) Token: 0x060091C5 RID: 37317 RVA: 0x00256758 File Offset: 0x00254958
		public unsafe IKEffector primaryHandEffector
		{
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 636922, XrefRangeEnd = 636925, 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: 0x17003177 RID: 12663
		// (get) Token: 0x060091C6 RID: 37318 RVA: 0x002567B0 File Offset: 0x002549B0
		public unsafe IKEffector secondaryHandEffector
		{
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 636925, XrefRangeEnd = 636928, 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: 0x17003178 RID: 12664
		// (get) Token: 0x060091C7 RID: 37319 RVA: 0x00256808 File Offset: 0x00254A08
		public unsafe Transform primaryHand
		{
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 636928, XrefRangeEnd = 636931, 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: 0x17003179 RID: 12665
		// (get) Token: 0x060091C8 RID: 37320 RVA: 0x00256860 File Offset: 0x00254A60
		public unsafe Transform secondaryHand
		{
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 636931, XrefRangeEnd = 636934, 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: 0x060091C9 RID: 37321 RVA: 0x002568B8 File Offset: 0x00254AB8
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 636934, XrefRangeEnd = 636959, 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: 0x060091CA RID: 37322 RVA: 0x00256908 File Offset: 0x00254B08
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 636959, XrefRangeEnd = 636962, 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: 0x060091CB RID: 37323 RVA: 0x00256954 File Offset: 0x00254B54
		// 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, 100674507);
			Recoil.NativeMethodInfoPtr_SetHandRotations_Public_Void_Quaternion_Quaternion_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Recoil>.NativeClassPtr, 100674508);
			Recoil.NativeMethodInfoPtr_Fire_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Recoil>.NativeClassPtr, 100674509);
			Recoil.NativeMethodInfoPtr_OnModifyOffset_Protected_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Recoil>.NativeClassPtr, 100674510);
			Recoil.NativeMethodInfoPtr_AfterFBBIK_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Recoil>.NativeClassPtr, 100674511);
			Recoil.NativeMethodInfoPtr_AfterAimIK_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Recoil>.NativeClassPtr, 100674512);
			Recoil.NativeMethodInfoPtr_get_primaryHandEffector_Private_get_IKEffector_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Recoil>.NativeClassPtr, 100674513);
			Recoil.NativeMethodInfoPtr_get_secondaryHandEffector_Private_get_IKEffector_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Recoil>.NativeClassPtr, 100674514);
			Recoil.NativeMethodInfoPtr_get_primaryHand_Private_get_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Recoil>.NativeClassPtr, 100674515);
			Recoil.NativeMethodInfoPtr_get_secondaryHand_Private_get_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Recoil>.NativeClassPtr, 100674516);
			Recoil.NativeMethodInfoPtr_OnDestroy_Protected_Virtual_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Recoil>.NativeClassPtr, 100674517);
			Recoil.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Recoil>.NativeClassPtr, 100674518);
		}

		// Token: 0x060091CC RID: 37324 RVA: 0x002089BC File Offset: 0x00206BBC
		public Recoil(IntPtr pointer)
			: base(pointer)
		{
		}

		// Token: 0x1700315E RID: 12638
		// (get) Token: 0x060091CD RID: 37325 RVA: 0x00256C40 File Offset: 0x00254E40
		// (set) Token: 0x060091CE RID: 37326 RVA: 0x00256C74 File Offset: 0x00254E74
		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: 0x1700315F RID: 12639
		// (get) Token: 0x060091CF RID: 37327 RVA: 0x00256C9C File Offset: 0x00254E9C
		// (set) Token: 0x060091D0 RID: 37328 RVA: 0x00256CC4 File Offset: 0x00254EC4
		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: 0x17003160 RID: 12640
		// (get) Token: 0x060091D1 RID: 37329 RVA: 0x00256CE8 File Offset: 0x00254EE8
		// (set) Token: 0x060091D2 RID: 37330 RVA: 0x00256D10 File Offset: 0x00254F10
		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: 0x17003161 RID: 12641
		// (get) Token: 0x060091D3 RID: 37331 RVA: 0x00256D34 File Offset: 0x00254F34
		// (set) Token: 0x060091D4 RID: 37332 RVA: 0x00256D5C File Offset: 0x00254F5C
		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: 0x17003162 RID: 12642
		// (get) Token: 0x060091D5 RID: 37333 RVA: 0x00256D80 File Offset: 0x00254F80
		// (set) Token: 0x060091D6 RID: 37334 RVA: 0x00256DB4 File Offset: 0x00254FB4
		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: 0x17003163 RID: 12643
		// (get) Token: 0x060091D7 RID: 37335 RVA: 0x00256DDC File Offset: 0x00254FDC
		// (set) Token: 0x060091D8 RID: 37336 RVA: 0x00256E04 File Offset: 0x00255004
		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: 0x17003164 RID: 12644
		// (get) Token: 0x060091D9 RID: 37337 RVA: 0x00256E28 File Offset: 0x00255028
		// (set) Token: 0x060091DA RID: 37338 RVA: 0x00256E50 File Offset: 0x00255050
		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: 0x17003165 RID: 12645
		// (get) Token: 0x060091DB RID: 37339 RVA: 0x00256E74 File Offset: 0x00255074
		// (set) Token: 0x060091DC RID: 37340 RVA: 0x00256E9C File Offset: 0x0025509C
		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: 0x17003166 RID: 12646
		// (get) Token: 0x060091DD RID: 37341 RVA: 0x00256EC0 File Offset: 0x002550C0
		// (set) Token: 0x060091DE RID: 37342 RVA: 0x00256EE8 File Offset: 0x002550E8
		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: 0x17003167 RID: 12647
		// (get) Token: 0x060091DF RID: 37343 RVA: 0x00256F0C File Offset: 0x0025510C
		// (set) Token: 0x060091E0 RID: 37344 RVA: 0x00256F40 File Offset: 0x00255140
		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: 0x17003168 RID: 12648
		// (get) Token: 0x060091E1 RID: 37345 RVA: 0x00256F68 File Offset: 0x00255168
		// (set) Token: 0x060091E2 RID: 37346 RVA: 0x00256F90 File Offset: 0x00255190
		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: 0x17003169 RID: 12649
		// (get) Token: 0x060091E3 RID: 37347 RVA: 0x00256FB4 File Offset: 0x002551B4
		// (set) Token: 0x060091E4 RID: 37348 RVA: 0x00256FDC File Offset: 0x002551DC
		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: 0x1700316A RID: 12650
		// (get) Token: 0x060091E5 RID: 37349 RVA: 0x00257000 File Offset: 0x00255200
		// (set) Token: 0x060091E6 RID: 37350 RVA: 0x00257028 File Offset: 0x00255228
		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: 0x1700316B RID: 12651
		// (get) Token: 0x060091E7 RID: 37351 RVA: 0x0025704C File Offset: 0x0025524C
		// (set) Token: 0x060091E8 RID: 37352 RVA: 0x00257074 File Offset: 0x00255274
		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: 0x1700316C RID: 12652
		// (get) Token: 0x060091E9 RID: 37353 RVA: 0x00257098 File Offset: 0x00255298
		// (set) Token: 0x060091EA RID: 37354 RVA: 0x002570C0 File Offset: 0x002552C0
		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: 0x1700316D RID: 12653
		// (get) Token: 0x060091EB RID: 37355 RVA: 0x002570E4 File Offset: 0x002552E4
		// (set) Token: 0x060091EC RID: 37356 RVA: 0x0025710C File Offset: 0x0025530C
		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: 0x1700316E RID: 12654
		// (get) Token: 0x060091ED RID: 37357 RVA: 0x00257130 File Offset: 0x00255330
		// (set) Token: 0x060091EE RID: 37358 RVA: 0x00257158 File Offset: 0x00255358
		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: 0x1700316F RID: 12655
		// (get) Token: 0x060091EF RID: 37359 RVA: 0x0025717C File Offset: 0x0025537C
		// (set) Token: 0x060091F0 RID: 37360 RVA: 0x002571A4 File Offset: 0x002553A4
		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: 0x17003170 RID: 12656
		// (get) Token: 0x060091F1 RID: 37361 RVA: 0x002571C8 File Offset: 0x002553C8
		// (set) Token: 0x060091F2 RID: 37362 RVA: 0x002571F0 File Offset: 0x002553F0
		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: 0x17003171 RID: 12657
		// (get) Token: 0x060091F3 RID: 37363 RVA: 0x00257214 File Offset: 0x00255414
		// (set) Token: 0x060091F4 RID: 37364 RVA: 0x0025723C File Offset: 0x0025543C
		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: 0x17003172 RID: 12658
		// (get) Token: 0x060091F5 RID: 37365 RVA: 0x00257260 File Offset: 0x00255460
		// (set) Token: 0x060091F6 RID: 37366 RVA: 0x00257288 File Offset: 0x00255488
		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: 0x17003173 RID: 12659
		// (get) Token: 0x060091F7 RID: 37367 RVA: 0x002572AC File Offset: 0x002554AC
		// (set) Token: 0x060091F8 RID: 37368 RVA: 0x002572D4 File Offset: 0x002554D4
		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: 0x17003174 RID: 12660
		// (get) Token: 0x060091F9 RID: 37369 RVA: 0x002572F8 File Offset: 0x002554F8
		// (set) Token: 0x060091FA RID: 37370 RVA: 0x00257320 File Offset: 0x00255520
		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: 0x04006146 RID: 24902
		private static readonly IntPtr NativeFieldInfoPtr_aimIK;

		// Token: 0x04006147 RID: 24903
		private static readonly IntPtr NativeFieldInfoPtr_aimIKSolvedLast;

		// Token: 0x04006148 RID: 24904
		private static readonly IntPtr NativeFieldInfoPtr_handedness;

		// Token: 0x04006149 RID: 24905
		private static readonly IntPtr NativeFieldInfoPtr_twoHanded;

		// Token: 0x0400614A RID: 24906
		private static readonly IntPtr NativeFieldInfoPtr_recoilWeight;

		// Token: 0x0400614B RID: 24907
		private static readonly IntPtr NativeFieldInfoPtr_magnitudeRandom;

		// Token: 0x0400614C RID: 24908
		private static readonly IntPtr NativeFieldInfoPtr_rotationRandom;

		// Token: 0x0400614D RID: 24909
		private static readonly IntPtr NativeFieldInfoPtr_handRotationOffset;

		// Token: 0x0400614E RID: 24910
		private static readonly IntPtr NativeFieldInfoPtr_blendTime;

		// Token: 0x0400614F RID: 24911
		private static readonly IntPtr NativeFieldInfoPtr_offsets;

		// Token: 0x04006150 RID: 24912
		private static readonly IntPtr NativeFieldInfoPtr_rotationOffset;

		// Token: 0x04006151 RID: 24913
		private static readonly IntPtr NativeFieldInfoPtr_magnitudeMlp;

		// Token: 0x04006152 RID: 24914
		private static readonly IntPtr NativeFieldInfoPtr_endTime;

		// Token: 0x04006153 RID: 24915
		private static readonly IntPtr NativeFieldInfoPtr_handRotation;

		// Token: 0x04006154 RID: 24916
		private static readonly IntPtr NativeFieldInfoPtr_secondaryHandRelativeRotation;

		// Token: 0x04006155 RID: 24917
		private static readonly IntPtr NativeFieldInfoPtr_randomRotation;

		// Token: 0x04006156 RID: 24918
		private static readonly IntPtr NativeFieldInfoPtr_length;

		// Token: 0x04006157 RID: 24919
		private static readonly IntPtr NativeFieldInfoPtr_initiated;

		// Token: 0x04006158 RID: 24920
		private static readonly IntPtr NativeFieldInfoPtr_blendWeight;

		// Token: 0x04006159 RID: 24921
		private static readonly IntPtr NativeFieldInfoPtr_w;

		// Token: 0x0400615A RID: 24922
		private static readonly IntPtr NativeFieldInfoPtr_primaryHandRotation;

		// Token: 0x0400615B RID: 24923
		private static readonly IntPtr NativeFieldInfoPtr_handRotationsSet;

		// Token: 0x0400615C RID: 24924
		private static readonly IntPtr NativeFieldInfoPtr_aimIKAxis;

		// Token: 0x0400615D RID: 24925
		private static readonly IntPtr NativeMethodInfoPtr_get_isFinished_Public_get_Boolean_0;

		// Token: 0x0400615E RID: 24926
		private static readonly IntPtr NativeMethodInfoPtr_SetHandRotations_Public_Void_Quaternion_Quaternion_0;

		// Token: 0x0400615F RID: 24927
		private static readonly IntPtr NativeMethodInfoPtr_Fire_Public_Void_Single_0;

		// Token: 0x04006160 RID: 24928
		private static readonly IntPtr NativeMethodInfoPtr_OnModifyOffset_Protected_Virtual_Void_0;

		// Token: 0x04006161 RID: 24929
		private static readonly IntPtr NativeMethodInfoPtr_AfterFBBIK_Private_Void_0;

		// Token: 0x04006162 RID: 24930
		private static readonly IntPtr NativeMethodInfoPtr_AfterAimIK_Private_Void_0;

		// Token: 0x04006163 RID: 24931
		private static readonly IntPtr NativeMethodInfoPtr_get_primaryHandEffector_Private_get_IKEffector_0;

		// Token: 0x04006164 RID: 24932
		private static readonly IntPtr NativeMethodInfoPtr_get_secondaryHandEffector_Private_get_IKEffector_0;

		// Token: 0x04006165 RID: 24933
		private static readonly IntPtr NativeMethodInfoPtr_get_primaryHand_Private_get_Transform_0;

		// Token: 0x04006166 RID: 24934
		private static readonly IntPtr NativeMethodInfoPtr_get_secondaryHand_Private_get_Transform_0;

		// Token: 0x04006167 RID: 24935
		private static readonly IntPtr NativeMethodInfoPtr_OnDestroy_Protected_Virtual_Void_0;

		// Token: 0x04006168 RID: 24936
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

		// Token: 0x020004EB RID: 1259
		[Serializable]
		public class RecoilOffset : Il2CppSystem.Object
		{
			// Token: 0x060091FB RID: 37371 RVA: 0x00257344 File Offset: 0x00255544
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 636776, RefRangeEnd = 636777, XrefRangeStart = 636775, XrefRangeEnd = 636776, 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: 0x060091FC RID: 37372 RVA: 0x00257388 File Offset: 0x00255588
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 636783, RefRangeEnd = 636784, XrefRangeStart = 636777, XrefRangeEnd = 636783, 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: 0x060091FD RID: 37373 RVA: 0x00257430 File Offset: 0x00255630
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 636784, XrefRangeEnd = 636785, 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: 0x060091FE RID: 37374 RVA: 0x0025747C File Offset: 0x0025567C
			// 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, 100674519);
				Recoil.RecoilOffset.NativeMethodInfoPtr_Apply_Public_Void_IKSolverFullBodyBiped_Quaternion_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Recoil.RecoilOffset>.NativeClassPtr, 100674520);
				Recoil.RecoilOffset.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Recoil.RecoilOffset>.NativeClassPtr, 100674521);
			}

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

			// Token: 0x1700317A RID: 12666
			// (get) Token: 0x06009200 RID: 37376 RVA: 0x0025755C File Offset: 0x0025575C
			// (set) Token: 0x06009201 RID: 37377 RVA: 0x00257584 File Offset: 0x00255784
			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: 0x1700317B RID: 12667
			// (get) Token: 0x06009202 RID: 37378 RVA: 0x002575A8 File Offset: 0x002557A8
			// (set) Token: 0x06009203 RID: 37379 RVA: 0x002575D0 File Offset: 0x002557D0
			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: 0x1700317C RID: 12668
			// (get) Token: 0x06009204 RID: 37380 RVA: 0x002575F4 File Offset: 0x002557F4
			// (set) Token: 0x06009205 RID: 37381 RVA: 0x0025761C File Offset: 0x0025581C
			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: 0x1700317D RID: 12669
			// (get) Token: 0x06009206 RID: 37382 RVA: 0x00257640 File Offset: 0x00255840
			// (set) Token: 0x06009207 RID: 37383 RVA: 0x00257674 File Offset: 0x00255874
			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: 0x1700317E RID: 12670
			// (get) Token: 0x06009208 RID: 37384 RVA: 0x0025769C File Offset: 0x0025589C
			// (set) Token: 0x06009209 RID: 37385 RVA: 0x002576C4 File Offset: 0x002558C4
			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: 0x1700317F RID: 12671
			// (get) Token: 0x0600920A RID: 37386 RVA: 0x002576E8 File Offset: 0x002558E8
			// (set) Token: 0x0600920B RID: 37387 RVA: 0x00257710 File Offset: 0x00255910
			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: 0x04006169 RID: 24937
			private static readonly IntPtr NativeFieldInfoPtr_offset;

			// Token: 0x0400616A RID: 24938
			private static readonly IntPtr NativeFieldInfoPtr_additivity;

			// Token: 0x0400616B RID: 24939
			private static readonly IntPtr NativeFieldInfoPtr_maxAdditiveOffsetMag;

			// Token: 0x0400616C RID: 24940
			private static readonly IntPtr NativeFieldInfoPtr_effectorLinks;

			// Token: 0x0400616D RID: 24941
			private static readonly IntPtr NativeFieldInfoPtr_additiveOffset;

			// Token: 0x0400616E RID: 24942
			private static readonly IntPtr NativeFieldInfoPtr_lastOffset;

			// Token: 0x0400616F RID: 24943
			private static readonly IntPtr NativeMethodInfoPtr_Start_Public_Void_0;

			// Token: 0x04006170 RID: 24944
			private static readonly IntPtr NativeMethodInfoPtr_Apply_Public_Void_IKSolverFullBodyBiped_Quaternion_Single_Single_Single_0;

			// Token: 0x04006171 RID: 24945
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

			// Token: 0x020004EC RID: 1260
			[Serializable]
			public class EffectorLink : Il2CppSystem.Object
			{
				// Token: 0x0600920C RID: 37388 RVA: 0x00257734 File Offset: 0x00255934
				[CallerCount(1664)]
				[CachedScanResults(RefRangeStart = 7711, RefRangeEnd = 9375, XrefRangeStart = 7711, XrefRangeEnd = 9375, 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: 0x0600920D RID: 37389 RVA: 0x00257780 File Offset: 0x00255980
				// 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, 100674522);
				}

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

				// Token: 0x17003180 RID: 12672
				// (get) Token: 0x0600920F RID: 37391 RVA: 0x002577E8 File Offset: 0x002559E8
				// (set) Token: 0x06009210 RID: 37392 RVA: 0x00257810 File Offset: 0x00255A10
				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: 0x17003181 RID: 12673
				// (get) Token: 0x06009211 RID: 37393 RVA: 0x00257834 File Offset: 0x00255A34
				// (set) Token: 0x06009212 RID: 37394 RVA: 0x0025785C File Offset: 0x00255A5C
				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: 0x04006172 RID: 24946
				private static readonly IntPtr NativeFieldInfoPtr_effector;

				// Token: 0x04006173 RID: 24947
				private static readonly IntPtr NativeFieldInfoPtr_weight;

				// Token: 0x04006174 RID: 24948
				private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
			}
		}

		// Token: 0x020004ED RID: 1261
		[Serializable]
		public enum Handedness
		{
			// Token: 0x04006176 RID: 24950
			Right,
			// Token: 0x04006177 RID: 24951
			Left
		}
	}
}