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

namespace RootMotion.FinalIK
{
	// Token: 0x02000489 RID: 1161
	[Serializable]
	public class IKSolver : Il2CppSystem.Object
	{
		// Token: 0x060088CF RID: 35023 RVA: 0x0022EF2C File Offset: 0x0022D12C
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 630143, XrefRangeEnd = 630145, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe bool IsValid()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolver.NativeMethodInfoPtr_IsValid_Public_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x060088D0 RID: 35024 RVA: 0x0022EF7C File Offset: 0x0022D17C
		[CallerCount(0)]
		public unsafe virtual bool IsValid(ref string message)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				ref IntPtr ptr2 = ref *ptr;
				IntPtr intPtr = IL2CPP.ManagedStringToIl2Cpp(message);
				ptr2 = &intPtr;
				IntPtr intPtr3;
				IntPtr intPtr2 = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), IKSolver.NativeMethodInfoPtr_IsValid_Public_Abstract_Virtual_New_Boolean_byref_String_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr3);
				Il2CppException.RaiseExceptionIfNecessary(intPtr3);
				message = IL2CPP.Il2CppStringToManaged(intPtr);
				return *IL2CPP.il2cpp_object_unbox(intPtr2);
			}
		}

		// Token: 0x060088D1 RID: 35025 RVA: 0x0022F008 File Offset: 0x0022D208
		[CallerCount(14)]
		[CachedScanResults(RefRangeStart = 630160, RefRangeEnd = 630174, XrefRangeStart = 630145, XrefRangeEnd = 630160, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void Initiate(Transform root)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(root);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolver.NativeMethodInfoPtr_Initiate_Public_Void_Transform_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}
		}

		// Token: 0x060088D2 RID: 35026 RVA: 0x0022F064 File Offset: 0x0022D264
		[CallerCount(18)]
		[CachedScanResults(RefRangeStart = 630177, RefRangeEnd = 630195, XrefRangeStart = 630174, XrefRangeEnd = 630177, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void Update()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolver.NativeMethodInfoPtr_Update_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x060088D3 RID: 35027 RVA: 0x0022F0A8 File Offset: 0x0022D2A8
		[CallerCount(0)]
		public unsafe virtual Vector3 GetIKPosition()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), IKSolver.NativeMethodInfoPtr_GetIKPosition_Public_Virtual_New_Vector3_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x060088D4 RID: 35028 RVA: 0x0022F104 File Offset: 0x0022D304
		[CallerCount(0)]
		public unsafe void SetIKPosition(Vector3 position)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref position;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolver.NativeMethodInfoPtr_SetIKPosition_Public_Void_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}
		}

		// Token: 0x060088D5 RID: 35029 RVA: 0x0022F158 File Offset: 0x0022D358
		[CallerCount(0)]
		public unsafe float GetIKPositionWeight()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolver.NativeMethodInfoPtr_GetIKPositionWeight_Public_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x060088D6 RID: 35030 RVA: 0x0022F1A8 File Offset: 0x0022D3A8
		[CallerCount(31)]
		[CachedScanResults(RefRangeStart = 630196, RefRangeEnd = 630227, XrefRangeStart = 630195, XrefRangeEnd = 630196, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void SetIKPositionWeight(float weight)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref weight;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolver.NativeMethodInfoPtr_SetIKPositionWeight_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}
		}

		// Token: 0x060088D7 RID: 35031 RVA: 0x0022F1FC File Offset: 0x0022D3FC
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 11374, RefRangeEnd = 11375, XrefRangeStart = 11374, XrefRangeEnd = 11375, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe Transform GetRoot()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolver.NativeMethodInfoPtr_GetRoot_Public_Transform_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			IntPtr intPtr3 = intPtr;
			return (intPtr3 != 0) ? new Transform(intPtr3) : null;
		}

		// Token: 0x17002E75 RID: 11893
		// (get) Token: 0x060088D8 RID: 35032 RVA: 0x0022F254 File Offset: 0x0022D454
		// (set) Token: 0x060088D9 RID: 35033 RVA: 0x0022F2A4 File Offset: 0x0022D4A4
		public unsafe bool initiated
		{
			[CallerCount(0)]
			get
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolver.NativeMethodInfoPtr_get_initiated_Public_get_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 43741, RefRangeEnd = 43743, XrefRangeStart = 43741, XrefRangeEnd = 43743, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			set
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				checked
				{
					IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref value;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolver.NativeMethodInfoPtr_set_initiated_Private_set_Void_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				}
			}
		}

		// Token: 0x060088DA RID: 35034 RVA: 0x0022F2F8 File Offset: 0x0022D4F8
		[CallerCount(0)]
		public unsafe virtual Il2CppReferenceArray<IKSolver.Point> GetPoints()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), IKSolver.NativeMethodInfoPtr_GetPoints_Public_Abstract_Virtual_New_Il2CppReferenceArray_1_Point_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			IntPtr intPtr3 = intPtr;
			return (intPtr3 != 0) ? new Il2CppReferenceArray<IKSolver.Point>(intPtr3) : null;
		}

		// Token: 0x060088DB RID: 35035 RVA: 0x0022F35C File Offset: 0x0022D55C
		[CallerCount(0)]
		public unsafe virtual IKSolver.Point GetPoint(Transform transform)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(transform);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), IKSolver.NativeMethodInfoPtr_GetPoint_Public_Abstract_Virtual_New_Point_Transform_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				IntPtr intPtr3 = intPtr;
				return (intPtr3 != 0) ? new IKSolver.Point(intPtr3) : null;
			}
		}

		// Token: 0x060088DC RID: 35036 RVA: 0x0022F3D4 File Offset: 0x0022D5D4
		[CallerCount(0)]
		public unsafe virtual void FixTransforms()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), IKSolver.NativeMethodInfoPtr_FixTransforms_Public_Abstract_Virtual_New_Void_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x060088DD RID: 35037 RVA: 0x0022F424 File Offset: 0x0022D624
		[CallerCount(0)]
		public unsafe virtual void StoreDefaultLocalState()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), IKSolver.NativeMethodInfoPtr_StoreDefaultLocalState_Public_Abstract_Virtual_New_Void_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x060088DE RID: 35038 RVA: 0x0022F474 File Offset: 0x0022D674
		[CallerCount(0)]
		public unsafe virtual void OnInitiate()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), IKSolver.NativeMethodInfoPtr_OnInitiate_Protected_Abstract_Virtual_New_Void_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x060088DF RID: 35039 RVA: 0x0022F4C4 File Offset: 0x0022D6C4
		[CallerCount(0)]
		public unsafe virtual void OnUpdate()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IL2CPP.il2cpp_object_get_virtual_method(IL2CPP.Il2CppObjectBaseToPtr(this), IKSolver.NativeMethodInfoPtr_OnUpdate_Protected_Abstract_Virtual_New_Void_0), IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x060088E0 RID: 35040 RVA: 0x0022F514 File Offset: 0x0022D714
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 630228, RefRangeEnd = 630230, XrefRangeStart = 630227, XrefRangeEnd = 630228, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void LogWarning(string message)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.ManagedStringToIl2Cpp(message);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolver.NativeMethodInfoPtr_LogWarning_Protected_Void_String_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}
		}

		// Token: 0x060088E1 RID: 35041 RVA: 0x0022F570 File Offset: 0x0022D770
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 630236, RefRangeEnd = 630238, XrefRangeStart = 630230, XrefRangeEnd = 630236, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe static Transform ContainsDuplicateBone(Il2CppReferenceArray<IKSolver.Bone> bones)
		{
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(bones);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolver.NativeMethodInfoPtr_ContainsDuplicateBone_Public_Static_Transform_Il2CppReferenceArray_1_Bone_0, 0, (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				IntPtr intPtr3 = intPtr;
				return (intPtr3 != 0) ? new Transform(intPtr3) : null;
			}
		}

		// Token: 0x060088E2 RID: 35042 RVA: 0x0022F5D0 File Offset: 0x0022D7D0
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 630238, XrefRangeEnd = 630240, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe static bool HierarchyIsValid(Il2CppReferenceArray<IKSolver.Bone> bones)
		{
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(bones);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolver.NativeMethodInfoPtr_HierarchyIsValid_Public_Static_Boolean_Il2CppReferenceArray_1_Bone_0, 0, (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}
		}

		// Token: 0x060088E3 RID: 35043 RVA: 0x0022F628 File Offset: 0x0022D828
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 630240, XrefRangeEnd = 630250, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe static float PreSolveBones(ref Il2CppReferenceArray<IKSolver.Bone> bones)
		{
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				ref IntPtr ptr2 = ref *ptr;
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtr(bones);
				ptr2 = &intPtr;
				IntPtr intPtr3;
				IntPtr intPtr2 = IL2CPP.il2cpp_runtime_invoke(IKSolver.NativeMethodInfoPtr_PreSolveBones_Protected_Static_Single_byref_Il2CppReferenceArray_1_Bone_0, 0, (void**)ptr, ref intPtr3);
				Il2CppException.RaiseExceptionIfNecessary(intPtr3);
				IntPtr intPtr4 = intPtr;
				bones = ((intPtr4 == 0) ? null : new Il2CppReferenceArray(intPtr4));
				return *IL2CPP.il2cpp_object_unbox(intPtr2);
			}
		}

		// Token: 0x060088E4 RID: 35044 RVA: 0x0022F6A0 File Offset: 0x0022D8A0
		[CallerCount(8)]
		[CachedScanResults(RefRangeStart = 630251, RefRangeEnd = 630259, XrefRangeStart = 630250, XrefRangeEnd = 630251, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe IKSolver()
			: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<IKSolver>.NativeClassPtr))
		{
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolver.NativeMethodInfoPtr__ctor_Protected_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x060088E5 RID: 35045 RVA: 0x0022F6EC File Offset: 0x0022D8EC
		// Note: this type is marked as 'beforefieldinit'.
		static IKSolver()
		{
			Il2CppClassPointerStore<IKSolver>.NativeClassPtr = IL2CPP.GetIl2CppClass("Assembly-CSharp.dll", "RootMotion.FinalIK", "IKSolver");
			IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<IKSolver>.NativeClassPtr);
			IKSolver.NativeFieldInfoPtr_IKPosition = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, "IKPosition");
			IKSolver.NativeFieldInfoPtr_IKPositionWeight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, "IKPositionWeight");
			IKSolver.NativeFieldInfoPtr__initiated_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, "<initiated>k__BackingField");
			IKSolver.NativeFieldInfoPtr_OnPreInitiate = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, "OnPreInitiate");
			IKSolver.NativeFieldInfoPtr_OnPostInitiate = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, "OnPostInitiate");
			IKSolver.NativeFieldInfoPtr_OnPreUpdate = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, "OnPreUpdate");
			IKSolver.NativeFieldInfoPtr_OnPostUpdate = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, "OnPostUpdate");
			IKSolver.NativeFieldInfoPtr_firstInitiation = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, "firstInitiation");
			IKSolver.NativeFieldInfoPtr_root = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, "root");
			IKSolver.NativeMethodInfoPtr_IsValid_Public_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100673697);
			IKSolver.NativeMethodInfoPtr_IsValid_Public_Abstract_Virtual_New_Boolean_byref_String_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100673698);
			IKSolver.NativeMethodInfoPtr_Initiate_Public_Void_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100673699);
			IKSolver.NativeMethodInfoPtr_Update_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100673700);
			IKSolver.NativeMethodInfoPtr_GetIKPosition_Public_Virtual_New_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100673701);
			IKSolver.NativeMethodInfoPtr_SetIKPosition_Public_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100673702);
			IKSolver.NativeMethodInfoPtr_GetIKPositionWeight_Public_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100673703);
			IKSolver.NativeMethodInfoPtr_SetIKPositionWeight_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100673704);
			IKSolver.NativeMethodInfoPtr_GetRoot_Public_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100673705);
			IKSolver.NativeMethodInfoPtr_get_initiated_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100673706);
			IKSolver.NativeMethodInfoPtr_set_initiated_Private_set_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100673707);
			IKSolver.NativeMethodInfoPtr_GetPoints_Public_Abstract_Virtual_New_Il2CppReferenceArray_1_Point_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100673708);
			IKSolver.NativeMethodInfoPtr_GetPoint_Public_Abstract_Virtual_New_Point_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100673709);
			IKSolver.NativeMethodInfoPtr_FixTransforms_Public_Abstract_Virtual_New_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100673710);
			IKSolver.NativeMethodInfoPtr_StoreDefaultLocalState_Public_Abstract_Virtual_New_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100673711);
			IKSolver.NativeMethodInfoPtr_OnInitiate_Protected_Abstract_Virtual_New_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100673712);
			IKSolver.NativeMethodInfoPtr_OnUpdate_Protected_Abstract_Virtual_New_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100673713);
			IKSolver.NativeMethodInfoPtr_LogWarning_Protected_Void_String_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100673714);
			IKSolver.NativeMethodInfoPtr_ContainsDuplicateBone_Public_Static_Transform_Il2CppReferenceArray_1_Bone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100673715);
			IKSolver.NativeMethodInfoPtr_HierarchyIsValid_Public_Static_Boolean_Il2CppReferenceArray_1_Bone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100673716);
			IKSolver.NativeMethodInfoPtr_PreSolveBones_Protected_Static_Single_byref_Il2CppReferenceArray_1_Bone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100673717);
			IKSolver.NativeMethodInfoPtr__ctor_Protected_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100673718);
		}

		// Token: 0x060088E6 RID: 35046 RVA: 0x0000A74C File Offset: 0x0000894C
		public IKSolver(IntPtr pointer)
			: base(pointer)
		{
		}

		// Token: 0x17002E6C RID: 11884
		// (get) Token: 0x060088E7 RID: 35047 RVA: 0x0022F988 File Offset: 0x0022DB88
		// (set) Token: 0x060088E8 RID: 35048 RVA: 0x0022F9B0 File Offset: 0x0022DBB0
		public unsafe Vector3 IKPosition
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.NativeFieldInfoPtr_IKPosition);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.NativeFieldInfoPtr_IKPosition)) = value;
			}
		}

		// Token: 0x17002E6D RID: 11885
		// (get) Token: 0x060088E9 RID: 35049 RVA: 0x0022F9D4 File Offset: 0x0022DBD4
		// (set) Token: 0x060088EA RID: 35050 RVA: 0x0022F9FC File Offset: 0x0022DBFC
		public unsafe float IKPositionWeight
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.NativeFieldInfoPtr_IKPositionWeight);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.NativeFieldInfoPtr_IKPositionWeight)) = value;
			}
		}

		// Token: 0x17002E6E RID: 11886
		// (get) Token: 0x060088EB RID: 35051 RVA: 0x0022FA20 File Offset: 0x0022DC20
		// (set) Token: 0x060088EC RID: 35052 RVA: 0x0022FA48 File Offset: 0x0022DC48
		public unsafe bool _initiated_k__BackingField
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.NativeFieldInfoPtr__initiated_k__BackingField);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.NativeFieldInfoPtr__initiated_k__BackingField)) = value;
			}
		}

		// Token: 0x17002E6F RID: 11887
		// (get) Token: 0x060088ED RID: 35053 RVA: 0x0022FA6C File Offset: 0x0022DC6C
		// (set) Token: 0x060088EE RID: 35054 RVA: 0x0022FAA0 File Offset: 0x0022DCA0
		public unsafe IKSolver.UpdateDelegate OnPreInitiate
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.NativeFieldInfoPtr_OnPreInitiate);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new IKSolver.UpdateDelegate(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.NativeFieldInfoPtr_OnPreInitiate), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002E70 RID: 11888
		// (get) Token: 0x060088EF RID: 35055 RVA: 0x0022FAC8 File Offset: 0x0022DCC8
		// (set) Token: 0x060088F0 RID: 35056 RVA: 0x0022FAFC File Offset: 0x0022DCFC
		public unsafe IKSolver.UpdateDelegate OnPostInitiate
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.NativeFieldInfoPtr_OnPostInitiate);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new IKSolver.UpdateDelegate(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.NativeFieldInfoPtr_OnPostInitiate), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002E71 RID: 11889
		// (get) Token: 0x060088F1 RID: 35057 RVA: 0x0022FB24 File Offset: 0x0022DD24
		// (set) Token: 0x060088F2 RID: 35058 RVA: 0x0022FB58 File Offset: 0x0022DD58
		public unsafe IKSolver.UpdateDelegate OnPreUpdate
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.NativeFieldInfoPtr_OnPreUpdate);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new IKSolver.UpdateDelegate(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.NativeFieldInfoPtr_OnPreUpdate), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002E72 RID: 11890
		// (get) Token: 0x060088F3 RID: 35059 RVA: 0x0022FB80 File Offset: 0x0022DD80
		// (set) Token: 0x060088F4 RID: 35060 RVA: 0x0022FBB4 File Offset: 0x0022DDB4
		public unsafe IKSolver.UpdateDelegate OnPostUpdate
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.NativeFieldInfoPtr_OnPostUpdate);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new IKSolver.UpdateDelegate(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.NativeFieldInfoPtr_OnPostUpdate), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002E73 RID: 11891
		// (get) Token: 0x060088F5 RID: 35061 RVA: 0x0022FBDC File Offset: 0x0022DDDC
		// (set) Token: 0x060088F6 RID: 35062 RVA: 0x0022FC04 File Offset: 0x0022DE04
		public unsafe bool firstInitiation
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.NativeFieldInfoPtr_firstInitiation);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.NativeFieldInfoPtr_firstInitiation)) = value;
			}
		}

		// Token: 0x17002E74 RID: 11892
		// (get) Token: 0x060088F7 RID: 35063 RVA: 0x0022FC28 File Offset: 0x0022DE28
		// (set) Token: 0x060088F8 RID: 35064 RVA: 0x0022FC5C File Offset: 0x0022DE5C
		public unsafe Transform root
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.NativeFieldInfoPtr_root);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new Transform(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.NativeFieldInfoPtr_root), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x04005B61 RID: 23393
		private static readonly IntPtr NativeFieldInfoPtr_IKPosition;

		// Token: 0x04005B62 RID: 23394
		private static readonly IntPtr NativeFieldInfoPtr_IKPositionWeight;

		// Token: 0x04005B63 RID: 23395
		private static readonly IntPtr NativeFieldInfoPtr__initiated_k__BackingField;

		// Token: 0x04005B64 RID: 23396
		private static readonly IntPtr NativeFieldInfoPtr_OnPreInitiate;

		// Token: 0x04005B65 RID: 23397
		private static readonly IntPtr NativeFieldInfoPtr_OnPostInitiate;

		// Token: 0x04005B66 RID: 23398
		private static readonly IntPtr NativeFieldInfoPtr_OnPreUpdate;

		// Token: 0x04005B67 RID: 23399
		private static readonly IntPtr NativeFieldInfoPtr_OnPostUpdate;

		// Token: 0x04005B68 RID: 23400
		private static readonly IntPtr NativeFieldInfoPtr_firstInitiation;

		// Token: 0x04005B69 RID: 23401
		private static readonly IntPtr NativeFieldInfoPtr_root;

		// Token: 0x04005B6A RID: 23402
		private static readonly IntPtr NativeMethodInfoPtr_IsValid_Public_Boolean_0;

		// Token: 0x04005B6B RID: 23403
		private static readonly IntPtr NativeMethodInfoPtr_IsValid_Public_Abstract_Virtual_New_Boolean_byref_String_0;

		// Token: 0x04005B6C RID: 23404
		private static readonly IntPtr NativeMethodInfoPtr_Initiate_Public_Void_Transform_0;

		// Token: 0x04005B6D RID: 23405
		private static readonly IntPtr NativeMethodInfoPtr_Update_Public_Void_0;

		// Token: 0x04005B6E RID: 23406
		private static readonly IntPtr NativeMethodInfoPtr_GetIKPosition_Public_Virtual_New_Vector3_0;

		// Token: 0x04005B6F RID: 23407
		private static readonly IntPtr NativeMethodInfoPtr_SetIKPosition_Public_Void_Vector3_0;

		// Token: 0x04005B70 RID: 23408
		private static readonly IntPtr NativeMethodInfoPtr_GetIKPositionWeight_Public_Single_0;

		// Token: 0x04005B71 RID: 23409
		private static readonly IntPtr NativeMethodInfoPtr_SetIKPositionWeight_Public_Void_Single_0;

		// Token: 0x04005B72 RID: 23410
		private static readonly IntPtr NativeMethodInfoPtr_GetRoot_Public_Transform_0;

		// Token: 0x04005B73 RID: 23411
		private static readonly IntPtr NativeMethodInfoPtr_get_initiated_Public_get_Boolean_0;

		// Token: 0x04005B74 RID: 23412
		private static readonly IntPtr NativeMethodInfoPtr_set_initiated_Private_set_Void_Boolean_0;

		// Token: 0x04005B75 RID: 23413
		private static readonly IntPtr NativeMethodInfoPtr_GetPoints_Public_Abstract_Virtual_New_Il2CppReferenceArray_1_Point_0;

		// Token: 0x04005B76 RID: 23414
		private static readonly IntPtr NativeMethodInfoPtr_GetPoint_Public_Abstract_Virtual_New_Point_Transform_0;

		// Token: 0x04005B77 RID: 23415
		private static readonly IntPtr NativeMethodInfoPtr_FixTransforms_Public_Abstract_Virtual_New_Void_0;

		// Token: 0x04005B78 RID: 23416
		private static readonly IntPtr NativeMethodInfoPtr_StoreDefaultLocalState_Public_Abstract_Virtual_New_Void_0;

		// Token: 0x04005B79 RID: 23417
		private static readonly IntPtr NativeMethodInfoPtr_OnInitiate_Protected_Abstract_Virtual_New_Void_0;

		// Token: 0x04005B7A RID: 23418
		private static readonly IntPtr NativeMethodInfoPtr_OnUpdate_Protected_Abstract_Virtual_New_Void_0;

		// Token: 0x04005B7B RID: 23419
		private static readonly IntPtr NativeMethodInfoPtr_LogWarning_Protected_Void_String_0;

		// Token: 0x04005B7C RID: 23420
		private static readonly IntPtr NativeMethodInfoPtr_ContainsDuplicateBone_Public_Static_Transform_Il2CppReferenceArray_1_Bone_0;

		// Token: 0x04005B7D RID: 23421
		private static readonly IntPtr NativeMethodInfoPtr_HierarchyIsValid_Public_Static_Boolean_Il2CppReferenceArray_1_Bone_0;

		// Token: 0x04005B7E RID: 23422
		private static readonly IntPtr NativeMethodInfoPtr_PreSolveBones_Protected_Static_Single_byref_Il2CppReferenceArray_1_Bone_0;

		// Token: 0x04005B7F RID: 23423
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Protected_Void_0;

		// Token: 0x0200048A RID: 1162
		[Serializable]
		public class Point : Il2CppSystem.Object
		{
			// Token: 0x060088F9 RID: 35065 RVA: 0x0022FC84 File Offset: 0x0022DE84
			[CallerCount(11)]
			[CachedScanResults(RefRangeStart = 630008, RefRangeEnd = 630019, XrefRangeStart = 630006, XrefRangeEnd = 630008, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void StoreDefaultLocalState()
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolver.Point.NativeMethodInfoPtr_StoreDefaultLocalState_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x060088FA RID: 35066 RVA: 0x0022FCC8 File Offset: 0x0022DEC8
			[CallerCount(11)]
			[CachedScanResults(RefRangeStart = 630025, RefRangeEnd = 630036, XrefRangeStart = 630019, XrefRangeEnd = 630025, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void FixTransform()
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolver.Point.NativeMethodInfoPtr_FixTransform_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x060088FB RID: 35067 RVA: 0x0022FD0C File Offset: 0x0022DF0C
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 630036, XrefRangeEnd = 630037, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void UpdateSolverPosition()
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolver.Point.NativeMethodInfoPtr_UpdateSolverPosition_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x060088FC RID: 35068 RVA: 0x0022FD50 File Offset: 0x0022DF50
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 630037, XrefRangeEnd = 630038, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void UpdateSolverLocalPosition()
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolver.Point.NativeMethodInfoPtr_UpdateSolverLocalPosition_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x060088FD RID: 35069 RVA: 0x0022FD94 File Offset: 0x0022DF94
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 630038, XrefRangeEnd = 630040, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void UpdateSolverState()
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolver.Point.NativeMethodInfoPtr_UpdateSolverState_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x060088FE RID: 35070 RVA: 0x0022FDD8 File Offset: 0x0022DFD8
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 630040, XrefRangeEnd = 630042, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void UpdateSolverLocalState()
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolver.Point.NativeMethodInfoPtr_UpdateSolverLocalState_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x060088FF RID: 35071 RVA: 0x0022FE1C File Offset: 0x0022E01C
			[CallerCount(5)]
			[CachedScanResults(RefRangeStart = 630044, RefRangeEnd = 630049, XrefRangeStart = 630042, XrefRangeEnd = 630044, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe Point()
				: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<IKSolver.Point>.NativeClassPtr))
			{
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolver.Point.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008900 RID: 35072 RVA: 0x0022FE68 File Offset: 0x0022E068
			// Note: this type is marked as 'beforefieldinit'.
			static Point()
			{
				Il2CppClassPointerStore<IKSolver.Point>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, "Point");
				IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<IKSolver.Point>.NativeClassPtr);
				IKSolver.Point.NativeFieldInfoPtr_transform = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolver.Point>.NativeClassPtr, "transform");
				IKSolver.Point.NativeFieldInfoPtr_weight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolver.Point>.NativeClassPtr, "weight");
				IKSolver.Point.NativeFieldInfoPtr_solverPosition = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolver.Point>.NativeClassPtr, "solverPosition");
				IKSolver.Point.NativeFieldInfoPtr_solverRotation = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolver.Point>.NativeClassPtr, "solverRotation");
				IKSolver.Point.NativeFieldInfoPtr_defaultLocalPosition = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolver.Point>.NativeClassPtr, "defaultLocalPosition");
				IKSolver.Point.NativeFieldInfoPtr_defaultLocalRotation = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolver.Point>.NativeClassPtr, "defaultLocalRotation");
				IKSolver.Point.NativeMethodInfoPtr_StoreDefaultLocalState_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.Point>.NativeClassPtr, 100673719);
				IKSolver.Point.NativeMethodInfoPtr_FixTransform_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.Point>.NativeClassPtr, 100673720);
				IKSolver.Point.NativeMethodInfoPtr_UpdateSolverPosition_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.Point>.NativeClassPtr, 100673721);
				IKSolver.Point.NativeMethodInfoPtr_UpdateSolverLocalPosition_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.Point>.NativeClassPtr, 100673722);
				IKSolver.Point.NativeMethodInfoPtr_UpdateSolverState_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.Point>.NativeClassPtr, 100673723);
				IKSolver.Point.NativeMethodInfoPtr_UpdateSolverLocalState_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.Point>.NativeClassPtr, 100673724);
				IKSolver.Point.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.Point>.NativeClassPtr, 100673725);
			}

			// Token: 0x06008901 RID: 35073 RVA: 0x0000A74C File Offset: 0x0000894C
			public Point(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002E76 RID: 11894
			// (get) Token: 0x06008902 RID: 35074 RVA: 0x0022FF98 File Offset: 0x0022E198
			// (set) Token: 0x06008903 RID: 35075 RVA: 0x0022FFCC File Offset: 0x0022E1CC
			public unsafe Transform transform
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.Point.NativeFieldInfoPtr_transform);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new Transform(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.Point.NativeFieldInfoPtr_transform), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x17002E77 RID: 11895
			// (get) Token: 0x06008904 RID: 35076 RVA: 0x0022FFF4 File Offset: 0x0022E1F4
			// (set) Token: 0x06008905 RID: 35077 RVA: 0x0023001C File Offset: 0x0022E21C
			public unsafe float weight
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.Point.NativeFieldInfoPtr_weight);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.Point.NativeFieldInfoPtr_weight)) = value;
				}
			}

			// Token: 0x17002E78 RID: 11896
			// (get) Token: 0x06008906 RID: 35078 RVA: 0x00230040 File Offset: 0x0022E240
			// (set) Token: 0x06008907 RID: 35079 RVA: 0x00230068 File Offset: 0x0022E268
			public unsafe Vector3 solverPosition
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.Point.NativeFieldInfoPtr_solverPosition);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.Point.NativeFieldInfoPtr_solverPosition)) = value;
				}
			}

			// Token: 0x17002E79 RID: 11897
			// (get) Token: 0x06008908 RID: 35080 RVA: 0x0023008C File Offset: 0x0022E28C
			// (set) Token: 0x06008909 RID: 35081 RVA: 0x002300B4 File Offset: 0x0022E2B4
			public unsafe Quaternion solverRotation
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.Point.NativeFieldInfoPtr_solverRotation);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.Point.NativeFieldInfoPtr_solverRotation)) = value;
				}
			}

			// Token: 0x17002E7A RID: 11898
			// (get) Token: 0x0600890A RID: 35082 RVA: 0x002300D8 File Offset: 0x0022E2D8
			// (set) Token: 0x0600890B RID: 35083 RVA: 0x00230100 File Offset: 0x0022E300
			public unsafe Vector3 defaultLocalPosition
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.Point.NativeFieldInfoPtr_defaultLocalPosition);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.Point.NativeFieldInfoPtr_defaultLocalPosition)) = value;
				}
			}

			// Token: 0x17002E7B RID: 11899
			// (get) Token: 0x0600890C RID: 35084 RVA: 0x00230124 File Offset: 0x0022E324
			// (set) Token: 0x0600890D RID: 35085 RVA: 0x0023014C File Offset: 0x0022E34C
			public unsafe Quaternion defaultLocalRotation
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.Point.NativeFieldInfoPtr_defaultLocalRotation);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.Point.NativeFieldInfoPtr_defaultLocalRotation)) = value;
				}
			}

			// Token: 0x04005B80 RID: 23424
			private static readonly IntPtr NativeFieldInfoPtr_transform;

			// Token: 0x04005B81 RID: 23425
			private static readonly IntPtr NativeFieldInfoPtr_weight;

			// Token: 0x04005B82 RID: 23426
			private static readonly IntPtr NativeFieldInfoPtr_solverPosition;

			// Token: 0x04005B83 RID: 23427
			private static readonly IntPtr NativeFieldInfoPtr_solverRotation;

			// Token: 0x04005B84 RID: 23428
			private static readonly IntPtr NativeFieldInfoPtr_defaultLocalPosition;

			// Token: 0x04005B85 RID: 23429
			private static readonly IntPtr NativeFieldInfoPtr_defaultLocalRotation;

			// Token: 0x04005B86 RID: 23430
			private static readonly IntPtr NativeMethodInfoPtr_StoreDefaultLocalState_Public_Void_0;

			// Token: 0x04005B87 RID: 23431
			private static readonly IntPtr NativeMethodInfoPtr_FixTransform_Public_Void_0;

			// Token: 0x04005B88 RID: 23432
			private static readonly IntPtr NativeMethodInfoPtr_UpdateSolverPosition_Public_Void_0;

			// Token: 0x04005B89 RID: 23433
			private static readonly IntPtr NativeMethodInfoPtr_UpdateSolverLocalPosition_Public_Void_0;

			// Token: 0x04005B8A RID: 23434
			private static readonly IntPtr NativeMethodInfoPtr_UpdateSolverState_Public_Void_0;

			// Token: 0x04005B8B RID: 23435
			private static readonly IntPtr NativeMethodInfoPtr_UpdateSolverLocalState_Public_Void_0;

			// Token: 0x04005B8C RID: 23436
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
		}

		// Token: 0x0200048B RID: 1163
		[Serializable]
		public class Bone : IKSolver.Point
		{
			// Token: 0x17002E81 RID: 11905
			// (get) Token: 0x0600890E RID: 35086 RVA: 0x00230170 File Offset: 0x0022E370
			// (set) Token: 0x0600890F RID: 35087 RVA: 0x002301C8 File Offset: 0x0022E3C8
			public unsafe RotationLimit rotationLimit
			{
				[CallerCount(17)]
				[CachedScanResults(RefRangeStart = 630060, RefRangeEnd = 630077, XrefRangeStart = 630049, XrefRangeEnd = 630060, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
				get
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IntPtr* ptr = null;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolver.Bone.NativeMethodInfoPtr_get_rotationLimit_Public_get_RotationLimit_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					IntPtr intPtr3 = intPtr;
					return (intPtr3 != 0) ? new RotationLimit(intPtr3) : null;
				}
				[CallerCount(0)]
				[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 630077, XrefRangeEnd = 630082, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
				set
				{
					IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					checked
					{
						IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
						*ptr = IL2CPP.Il2CppObjectBaseToPtr(value);
						IntPtr intPtr2;
						IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolver.Bone.NativeMethodInfoPtr_set_rotationLimit_Public_set_Void_RotationLimit_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
						Il2CppException.RaiseExceptionIfNecessary(intPtr2);
					}
				}
			}

			// Token: 0x06008910 RID: 35088 RVA: 0x00230224 File Offset: 0x0022E424
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 630094, RefRangeEnd = 630095, XrefRangeStart = 630082, XrefRangeEnd = 630094, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void Swing(Vector3 swingTarget, float weight = 1f)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref swingTarget;
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref weight;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolver.Bone.NativeMethodInfoPtr_Swing_Public_Void_Vector3_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008911 RID: 35089 RVA: 0x0023028C File Offset: 0x0022E48C
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 630095, XrefRangeEnd = 630103, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe static void SolverSwing(Il2CppReferenceArray<IKSolver.Bone> bones, int index, Vector3 swingTarget, float weight = 1f)
			{
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(bones);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref index;
				ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref swingTarget;
				ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref weight;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolver.Bone.NativeMethodInfoPtr_SolverSwing_Public_Static_Void_Il2CppReferenceArray_1_Bone_Int32_Vector3_Single_0, 0, (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008912 RID: 35090 RVA: 0x00230310 File Offset: 0x0022E510
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 630114, RefRangeEnd = 630115, XrefRangeStart = 630103, XrefRangeEnd = 630114, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void Swing2D(Vector3 swingTarget, float weight = 1f)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref swingTarget;
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref weight;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolver.Bone.NativeMethodInfoPtr_Swing2D_Public_Void_Vector3_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008913 RID: 35091 RVA: 0x00230378 File Offset: 0x0022E578
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 630115, XrefRangeEnd = 630116, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void SetToSolverPosition()
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolver.Bone.NativeMethodInfoPtr_SetToSolverPosition_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008914 RID: 35092 RVA: 0x002303BC File Offset: 0x0022E5BC
			[CallerCount(4)]
			[CachedScanResults(RefRangeStart = 630119, RefRangeEnd = 630123, XrefRangeStart = 630116, XrefRangeEnd = 630119, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe Bone()
				: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<IKSolver.Bone>.NativeClassPtr))
			{
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolver.Bone.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008915 RID: 35093 RVA: 0x00230408 File Offset: 0x0022E608
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 630123, XrefRangeEnd = 630127, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe Bone(Transform transform)
				: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<IKSolver.Bone>.NativeClassPtr))
			{
				checked
				{
					IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(transform);
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolver.Bone.NativeMethodInfoPtr__ctor_Public_Void_Transform_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				}
			}

			// Token: 0x06008916 RID: 35094 RVA: 0x0023046C File Offset: 0x0022E66C
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 630127, XrefRangeEnd = 630131, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe Bone(Transform transform, float weight)
				: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<IKSolver.Bone>.NativeClassPtr))
			{
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(transform);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref weight;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolver.Bone.NativeMethodInfoPtr__ctor_Public_Void_Transform_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008917 RID: 35095 RVA: 0x002304E4 File Offset: 0x0022E6E4
			// Note: this type is marked as 'beforefieldinit'.
			static Bone()
			{
				Il2CppClassPointerStore<IKSolver.Bone>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, "Bone");
				IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<IKSolver.Bone>.NativeClassPtr);
				IKSolver.Bone.NativeFieldInfoPtr_length = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolver.Bone>.NativeClassPtr, "length");
				IKSolver.Bone.NativeFieldInfoPtr_sqrMag = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolver.Bone>.NativeClassPtr, "sqrMag");
				IKSolver.Bone.NativeFieldInfoPtr_axis = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolver.Bone>.NativeClassPtr, "axis");
				IKSolver.Bone.NativeFieldInfoPtr__rotationLimit = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolver.Bone>.NativeClassPtr, "_rotationLimit");
				IKSolver.Bone.NativeFieldInfoPtr_isLimited = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolver.Bone>.NativeClassPtr, "isLimited");
				IKSolver.Bone.NativeMethodInfoPtr_get_rotationLimit_Public_get_RotationLimit_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.Bone>.NativeClassPtr, 100673726);
				IKSolver.Bone.NativeMethodInfoPtr_set_rotationLimit_Public_set_Void_RotationLimit_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.Bone>.NativeClassPtr, 100673727);
				IKSolver.Bone.NativeMethodInfoPtr_Swing_Public_Void_Vector3_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.Bone>.NativeClassPtr, 100673728);
				IKSolver.Bone.NativeMethodInfoPtr_SolverSwing_Public_Static_Void_Il2CppReferenceArray_1_Bone_Int32_Vector3_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.Bone>.NativeClassPtr, 100673729);
				IKSolver.Bone.NativeMethodInfoPtr_Swing2D_Public_Void_Vector3_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.Bone>.NativeClassPtr, 100673730);
				IKSolver.Bone.NativeMethodInfoPtr_SetToSolverPosition_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.Bone>.NativeClassPtr, 100673731);
				IKSolver.Bone.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.Bone>.NativeClassPtr, 100673732);
				IKSolver.Bone.NativeMethodInfoPtr__ctor_Public_Void_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.Bone>.NativeClassPtr, 100673733);
				IKSolver.Bone.NativeMethodInfoPtr__ctor_Public_Void_Transform_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.Bone>.NativeClassPtr, 100673734);
			}

			// Token: 0x06008918 RID: 35096 RVA: 0x00230627 File Offset: 0x0022E827
			public Bone(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002E7C RID: 11900
			// (get) Token: 0x06008919 RID: 35097 RVA: 0x00230630 File Offset: 0x0022E830
			// (set) Token: 0x0600891A RID: 35098 RVA: 0x00230658 File Offset: 0x0022E858
			public unsafe float length
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.Bone.NativeFieldInfoPtr_length);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.Bone.NativeFieldInfoPtr_length)) = value;
				}
			}

			// Token: 0x17002E7D RID: 11901
			// (get) Token: 0x0600891B RID: 35099 RVA: 0x0023067C File Offset: 0x0022E87C
			// (set) Token: 0x0600891C RID: 35100 RVA: 0x002306A4 File Offset: 0x0022E8A4
			public unsafe float sqrMag
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.Bone.NativeFieldInfoPtr_sqrMag);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.Bone.NativeFieldInfoPtr_sqrMag)) = value;
				}
			}

			// Token: 0x17002E7E RID: 11902
			// (get) Token: 0x0600891D RID: 35101 RVA: 0x002306C8 File Offset: 0x0022E8C8
			// (set) Token: 0x0600891E RID: 35102 RVA: 0x002306F0 File Offset: 0x0022E8F0
			public unsafe Vector3 axis
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.Bone.NativeFieldInfoPtr_axis);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.Bone.NativeFieldInfoPtr_axis)) = value;
				}
			}

			// Token: 0x17002E7F RID: 11903
			// (get) Token: 0x0600891F RID: 35103 RVA: 0x00230714 File Offset: 0x0022E914
			// (set) Token: 0x06008920 RID: 35104 RVA: 0x00230748 File Offset: 0x0022E948
			public unsafe RotationLimit _rotationLimit
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.Bone.NativeFieldInfoPtr__rotationLimit);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new RotationLimit(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.Bone.NativeFieldInfoPtr__rotationLimit), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x17002E80 RID: 11904
			// (get) Token: 0x06008921 RID: 35105 RVA: 0x00230770 File Offset: 0x0022E970
			// (set) Token: 0x06008922 RID: 35106 RVA: 0x00230798 File Offset: 0x0022E998
			public unsafe bool isLimited
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.Bone.NativeFieldInfoPtr_isLimited);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.Bone.NativeFieldInfoPtr_isLimited)) = value;
				}
			}

			// Token: 0x04005B8D RID: 23437
			private static readonly IntPtr NativeFieldInfoPtr_length;

			// Token: 0x04005B8E RID: 23438
			private static readonly IntPtr NativeFieldInfoPtr_sqrMag;

			// Token: 0x04005B8F RID: 23439
			private static readonly IntPtr NativeFieldInfoPtr_axis;

			// Token: 0x04005B90 RID: 23440
			private static readonly IntPtr NativeFieldInfoPtr__rotationLimit;

			// Token: 0x04005B91 RID: 23441
			private static readonly IntPtr NativeFieldInfoPtr_isLimited;

			// Token: 0x04005B92 RID: 23442
			private static readonly IntPtr NativeMethodInfoPtr_get_rotationLimit_Public_get_RotationLimit_0;

			// Token: 0x04005B93 RID: 23443
			private static readonly IntPtr NativeMethodInfoPtr_set_rotationLimit_Public_set_Void_RotationLimit_0;

			// Token: 0x04005B94 RID: 23444
			private static readonly IntPtr NativeMethodInfoPtr_Swing_Public_Void_Vector3_Single_0;

			// Token: 0x04005B95 RID: 23445
			private static readonly IntPtr NativeMethodInfoPtr_SolverSwing_Public_Static_Void_Il2CppReferenceArray_1_Bone_Int32_Vector3_Single_0;

			// Token: 0x04005B96 RID: 23446
			private static readonly IntPtr NativeMethodInfoPtr_Swing2D_Public_Void_Vector3_Single_0;

			// Token: 0x04005B97 RID: 23447
			private static readonly IntPtr NativeMethodInfoPtr_SetToSolverPosition_Public_Void_0;

			// Token: 0x04005B98 RID: 23448
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

			// Token: 0x04005B99 RID: 23449
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_Transform_0;

			// Token: 0x04005B9A RID: 23450
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_Transform_Single_0;
		}

		// Token: 0x0200048C RID: 1164
		[Serializable]
		public class Node : IKSolver.Point
		{
			// Token: 0x06008923 RID: 35107 RVA: 0x002307BC File Offset: 0x0022E9BC
			[CallerCount(5)]
			[CachedScanResults(RefRangeStart = 630044, RefRangeEnd = 630049, XrefRangeStart = 630044, XrefRangeEnd = 630049, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe Node()
				: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<IKSolver.Node>.NativeClassPtr))
			{
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolver.Node.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008924 RID: 35108 RVA: 0x00230808 File Offset: 0x0022EA08
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 630134, RefRangeEnd = 630136, XrefRangeStart = 630131, XrefRangeEnd = 630134, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe Node(Transform transform)
				: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<IKSolver.Node>.NativeClassPtr))
			{
				checked
				{
					IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(transform);
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolver.Node.NativeMethodInfoPtr__ctor_Public_Void_Transform_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				}
			}

			// Token: 0x06008925 RID: 35109 RVA: 0x0023086C File Offset: 0x0022EA6C
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 630136, XrefRangeEnd = 630139, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe Node(Transform transform, float weight)
				: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<IKSolver.Node>.NativeClassPtr))
			{
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(transform);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref weight;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolver.Node.NativeMethodInfoPtr__ctor_Public_Void_Transform_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008926 RID: 35110 RVA: 0x002308E4 File Offset: 0x0022EAE4
			// Note: this type is marked as 'beforefieldinit'.
			static Node()
			{
				Il2CppClassPointerStore<IKSolver.Node>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, "Node");
				IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<IKSolver.Node>.NativeClassPtr);
				IKSolver.Node.NativeFieldInfoPtr_length = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolver.Node>.NativeClassPtr, "length");
				IKSolver.Node.NativeFieldInfoPtr_effectorPositionWeight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolver.Node>.NativeClassPtr, "effectorPositionWeight");
				IKSolver.Node.NativeFieldInfoPtr_effectorRotationWeight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolver.Node>.NativeClassPtr, "effectorRotationWeight");
				IKSolver.Node.NativeFieldInfoPtr_offset = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<IKSolver.Node>.NativeClassPtr, "offset");
				IKSolver.Node.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.Node>.NativeClassPtr, 100673735);
				IKSolver.Node.NativeMethodInfoPtr__ctor_Public_Void_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.Node>.NativeClassPtr, 100673736);
				IKSolver.Node.NativeMethodInfoPtr__ctor_Public_Void_Transform_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.Node>.NativeClassPtr, 100673737);
			}

			// Token: 0x06008927 RID: 35111 RVA: 0x00230627 File Offset: 0x0022E827
			public Node(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002E82 RID: 11906
			// (get) Token: 0x06008928 RID: 35112 RVA: 0x0023099C File Offset: 0x0022EB9C
			// (set) Token: 0x06008929 RID: 35113 RVA: 0x002309C4 File Offset: 0x0022EBC4
			public unsafe float length
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.Node.NativeFieldInfoPtr_length);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.Node.NativeFieldInfoPtr_length)) = value;
				}
			}

			// Token: 0x17002E83 RID: 11907
			// (get) Token: 0x0600892A RID: 35114 RVA: 0x002309E8 File Offset: 0x0022EBE8
			// (set) Token: 0x0600892B RID: 35115 RVA: 0x00230A10 File Offset: 0x0022EC10
			public unsafe float effectorPositionWeight
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.Node.NativeFieldInfoPtr_effectorPositionWeight);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.Node.NativeFieldInfoPtr_effectorPositionWeight)) = value;
				}
			}

			// Token: 0x17002E84 RID: 11908
			// (get) Token: 0x0600892C RID: 35116 RVA: 0x00230A34 File Offset: 0x0022EC34
			// (set) Token: 0x0600892D RID: 35117 RVA: 0x00230A5C File Offset: 0x0022EC5C
			public unsafe float effectorRotationWeight
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.Node.NativeFieldInfoPtr_effectorRotationWeight);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.Node.NativeFieldInfoPtr_effectorRotationWeight)) = value;
				}
			}

			// Token: 0x17002E85 RID: 11909
			// (get) Token: 0x0600892E RID: 35118 RVA: 0x00230A80 File Offset: 0x0022EC80
			// (set) Token: 0x0600892F RID: 35119 RVA: 0x00230AA8 File Offset: 0x0022ECA8
			public unsafe Vector3 offset
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.Node.NativeFieldInfoPtr_offset);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(IKSolver.Node.NativeFieldInfoPtr_offset)) = value;
				}
			}

			// Token: 0x04005B9B RID: 23451
			private static readonly IntPtr NativeFieldInfoPtr_length;

			// Token: 0x04005B9C RID: 23452
			private static readonly IntPtr NativeFieldInfoPtr_effectorPositionWeight;

			// Token: 0x04005B9D RID: 23453
			private static readonly IntPtr NativeFieldInfoPtr_effectorRotationWeight;

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

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

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

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

		// Token: 0x0200048D RID: 1165
		public sealed class UpdateDelegate : MulticastDelegate
		{
			// Token: 0x06008930 RID: 35120 RVA: 0x00230ACC File Offset: 0x0022ECCC
			[CallerCount(2079)]
			[CachedScanResults(RefRangeStart = 12621, RefRangeEnd = 14700, XrefRangeStart = 12621, XrefRangeEnd = 14700, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe UpdateDelegate(Il2CppSystem.Object @object, IntPtr method)
				: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<IKSolver.UpdateDelegate>.NativeClassPtr))
			{
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(@object);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref method;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolver.UpdateDelegate.NativeMethodInfoPtr__ctor_Public_Void_Object_IntPtr_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008931 RID: 35121 RVA: 0x00230B44 File Offset: 0x0022ED44
			[CallerCount(38)]
			[CachedScanResults(RefRangeStart = 153157, RefRangeEnd = 153195, XrefRangeStart = 153157, XrefRangeEnd = 153195, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void Invoke()
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolver.UpdateDelegate.NativeMethodInfoPtr_Invoke_Public_Virtual_New_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x06008932 RID: 35122 RVA: 0x00230B88 File Offset: 0x0022ED88
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 0, XrefRangeEnd = 0, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe IAsyncResult BeginInvoke(AsyncCallback callback, Il2CppSystem.Object @object)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(callback);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(@object);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolver.UpdateDelegate.NativeMethodInfoPtr_BeginInvoke_Public_Virtual_New_IAsyncResult_AsyncCallback_Object_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				IntPtr intPtr3 = intPtr;
				return (intPtr3 != 0) ? new IAsyncResult(intPtr3) : null;
			}

			// Token: 0x06008933 RID: 35123 RVA: 0x00230C10 File Offset: 0x0022EE10
			[CallerCount(3)]
			[CachedScanResults(RefRangeStart = 14711, RefRangeEnd = 14714, XrefRangeStart = 14711, XrefRangeEnd = 14714, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void EndInvoke(IAsyncResult result)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				checked
				{
					IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(result);
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolver.UpdateDelegate.NativeMethodInfoPtr_EndInvoke_Public_Virtual_New_Void_IAsyncResult_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				}
			}

			// Token: 0x06008934 RID: 35124 RVA: 0x00230C6C File Offset: 0x0022EE6C
			// Note: this type is marked as 'beforefieldinit'.
			static UpdateDelegate()
			{
				Il2CppClassPointerStore<IKSolver.UpdateDelegate>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, "UpdateDelegate");
				IKSolver.UpdateDelegate.NativeMethodInfoPtr__ctor_Public_Void_Object_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.UpdateDelegate>.NativeClassPtr, 100673738);
				IKSolver.UpdateDelegate.NativeMethodInfoPtr_Invoke_Public_Virtual_New_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.UpdateDelegate>.NativeClassPtr, 100673739);
				IKSolver.UpdateDelegate.NativeMethodInfoPtr_BeginInvoke_Public_Virtual_New_IAsyncResult_AsyncCallback_Object_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.UpdateDelegate>.NativeClassPtr, 100673740);
				IKSolver.UpdateDelegate.NativeMethodInfoPtr_EndInvoke_Public_Virtual_New_Void_IAsyncResult_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.UpdateDelegate>.NativeClassPtr, 100673741);
			}

			// Token: 0x06008935 RID: 35125 RVA: 0x00019081 File Offset: 0x00017281
			public UpdateDelegate(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x06008936 RID: 35126 RVA: 0x00230CDD File Offset: 0x0022EEDD
			public static implicit operator IKSolver.UpdateDelegate(Action A_0)
			{
				return DelegateSupport.ConvertDelegate<IKSolver.UpdateDelegate>(A_0);
			}

			// Token: 0x06008937 RID: 35127 RVA: 0x00230CE5 File Offset: 0x0022EEE5
			public static IKSolver.UpdateDelegate operator +(IKSolver.UpdateDelegate A_0, IKSolver.UpdateDelegate A_1)
			{
				return Delegate.Combine(A_0, A_1).Cast<IKSolver.UpdateDelegate>();
			}

			// Token: 0x06008938 RID: 35128 RVA: 0x00230CF3 File Offset: 0x0022EEF3
			public static IKSolver.UpdateDelegate operator -(IKSolver.UpdateDelegate A_0, IKSolver.UpdateDelegate A_1)
			{
				Delegate delegate2;
				Delegate @delegate = (delegate2 = Delegate.Remove(A_0, A_1));
				if (@delegate != null)
				{
					delegate2 = @delegate.Cast<IKSolver.UpdateDelegate>();
				}
				return delegate2;
			}

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

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

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

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

		// Token: 0x0200048E RID: 1166
		public sealed class IterationDelegate : MulticastDelegate
		{
			// Token: 0x06008939 RID: 35129 RVA: 0x00230D04 File Offset: 0x0022EF04
			[CallerCount(2079)]
			[CachedScanResults(RefRangeStart = 12621, RefRangeEnd = 14700, XrefRangeStart = 12621, XrefRangeEnd = 14700, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe IterationDelegate(Il2CppSystem.Object @object, IntPtr method)
				: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<IKSolver.IterationDelegate>.NativeClassPtr))
			{
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(@object);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref method;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolver.IterationDelegate.NativeMethodInfoPtr__ctor_Public_Void_Object_IntPtr_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x0600893A RID: 35130 RVA: 0x00230D7C File Offset: 0x0022EF7C
			[CallerCount(15)]
			[CachedScanResults(RefRangeStart = 216952, RefRangeEnd = 216967, XrefRangeStart = 216952, XrefRangeEnd = 216967, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void Invoke(int i)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				checked
				{
					IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref i;
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolver.IterationDelegate.NativeMethodInfoPtr_Invoke_Public_Virtual_New_Void_Int32_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				}
			}

			// Token: 0x0600893B RID: 35131 RVA: 0x00230DD0 File Offset: 0x0022EFD0
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 630139, XrefRangeEnd = 630143, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe IAsyncResult BeginInvoke(int i, AsyncCallback callback, Il2CppSystem.Object @object)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref i;
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(callback);
				ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(@object);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolver.IterationDelegate.NativeMethodInfoPtr_BeginInvoke_Public_Virtual_New_IAsyncResult_Int32_AsyncCallback_Object_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				IntPtr intPtr3 = intPtr;
				return (intPtr3 != 0) ? new IAsyncResult(intPtr3) : null;
			}

			// Token: 0x0600893C RID: 35132 RVA: 0x00230E68 File Offset: 0x0022F068
			[CallerCount(3)]
			[CachedScanResults(RefRangeStart = 14711, RefRangeEnd = 14714, XrefRangeStart = 14711, XrefRangeEnd = 14714, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void EndInvoke(IAsyncResult result)
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				checked
				{
					IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(result);
					IntPtr intPtr2;
					IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(IKSolver.IterationDelegate.NativeMethodInfoPtr_EndInvoke_Public_Virtual_New_Void_IAsyncResult_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
					Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				}
			}

			// Token: 0x0600893D RID: 35133 RVA: 0x00230EC4 File Offset: 0x0022F0C4
			// Note: this type is marked as 'beforefieldinit'.
			static IterationDelegate()
			{
				Il2CppClassPointerStore<IKSolver.IterationDelegate>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, "IterationDelegate");
				IKSolver.IterationDelegate.NativeMethodInfoPtr__ctor_Public_Void_Object_IntPtr_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.IterationDelegate>.NativeClassPtr, 100673742);
				IKSolver.IterationDelegate.NativeMethodInfoPtr_Invoke_Public_Virtual_New_Void_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.IterationDelegate>.NativeClassPtr, 100673743);
				IKSolver.IterationDelegate.NativeMethodInfoPtr_BeginInvoke_Public_Virtual_New_IAsyncResult_Int32_AsyncCallback_Object_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.IterationDelegate>.NativeClassPtr, 100673744);
				IKSolver.IterationDelegate.NativeMethodInfoPtr_EndInvoke_Public_Virtual_New_Void_IAsyncResult_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.IterationDelegate>.NativeClassPtr, 100673745);
			}

			// Token: 0x0600893E RID: 35134 RVA: 0x00019081 File Offset: 0x00017281
			public IterationDelegate(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x0600893F RID: 35135 RVA: 0x00230F35 File Offset: 0x0022F135
			public static implicit operator IKSolver.IterationDelegate(Action<int> A_0)
			{
				return DelegateSupport.ConvertDelegate<IKSolver.IterationDelegate>(A_0);
			}

			// Token: 0x06008940 RID: 35136 RVA: 0x00230F3D File Offset: 0x0022F13D
			public static IKSolver.IterationDelegate operator +(IKSolver.IterationDelegate A_0, IKSolver.IterationDelegate A_1)
			{
				return Delegate.Combine(A_0, A_1).Cast<IKSolver.IterationDelegate>();
			}

			// Token: 0x06008941 RID: 35137 RVA: 0x00230F4B File Offset: 0x0022F14B
			public static IKSolver.IterationDelegate operator -(IKSolver.IterationDelegate A_0, IKSolver.IterationDelegate A_1)
			{
				Delegate delegate2;
				Delegate @delegate = (delegate2 = Delegate.Remove(A_0, A_1));
				if (@delegate != null)
				{
					delegate2 = @delegate.Cast<IKSolver.IterationDelegate>();
				}
				return delegate2;
			}

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

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

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

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