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

namespace RootMotion.FinalIK
{
	// Token: 0x02000431 RID: 1073
	[Serializable]
	public class IKSolver : Il2CppSystem.Object
	{
		// Token: 0x0600807C RID: 32892 RVA: 0x0020C1F0 File Offset: 0x0020A3F0
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 597833, XrefRangeEnd = 597835, 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: 0x0600807D RID: 32893 RVA: 0x0020C240 File Offset: 0x0020A440
		[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: 0x0600807E RID: 32894 RVA: 0x0020C2CC File Offset: 0x0020A4CC
		[CallerCount(14)]
		[CachedScanResults(RefRangeStart = 597850, RefRangeEnd = 597864, XrefRangeStart = 597835, XrefRangeEnd = 597850, 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: 0x0600807F RID: 32895 RVA: 0x0020C328 File Offset: 0x0020A528
		[CallerCount(18)]
		[CachedScanResults(RefRangeStart = 597867, RefRangeEnd = 597885, XrefRangeStart = 597864, XrefRangeEnd = 597867, 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: 0x06008080 RID: 32896 RVA: 0x0020C36C File Offset: 0x0020A56C
		[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: 0x06008081 RID: 32897 RVA: 0x0020C3C8 File Offset: 0x0020A5C8
		[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: 0x06008082 RID: 32898 RVA: 0x0020C41C File Offset: 0x0020A61C
		[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: 0x06008083 RID: 32899 RVA: 0x0020C46C File Offset: 0x0020A66C
		[CallerCount(30)]
		[CachedScanResults(RefRangeStart = 597886, RefRangeEnd = 597916, XrefRangeStart = 597885, XrefRangeEnd = 597886, 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: 0x06008084 RID: 32900 RVA: 0x0020C4C0 File Offset: 0x0020A6C0
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 11058, RefRangeEnd = 11059, XrefRangeStart = 11058, XrefRangeEnd = 11059, 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: 0x17002BDA RID: 11226
		// (get) Token: 0x06008085 RID: 32901 RVA: 0x0020C518 File Offset: 0x0020A718
		// (set) Token: 0x06008086 RID: 32902 RVA: 0x0020C568 File Offset: 0x0020A768
		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 = 43775, RefRangeEnd = 43777, XrefRangeStart = 43775, XrefRangeEnd = 43777, 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: 0x06008087 RID: 32903 RVA: 0x0020C5BC File Offset: 0x0020A7BC
		[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: 0x06008088 RID: 32904 RVA: 0x0020C620 File Offset: 0x0020A820
		[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: 0x06008089 RID: 32905 RVA: 0x0020C698 File Offset: 0x0020A898
		[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: 0x0600808A RID: 32906 RVA: 0x0020C6E8 File Offset: 0x0020A8E8
		[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: 0x0600808B RID: 32907 RVA: 0x0020C738 File Offset: 0x0020A938
		[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: 0x0600808C RID: 32908 RVA: 0x0020C788 File Offset: 0x0020A988
		[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: 0x0600808D RID: 32909 RVA: 0x0020C7D8 File Offset: 0x0020A9D8
		[CallerCount(4)]
		[CachedScanResults(RefRangeStart = 597917, RefRangeEnd = 597921, XrefRangeStart = 597916, XrefRangeEnd = 597917, 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: 0x0600808E RID: 32910 RVA: 0x0020C834 File Offset: 0x0020AA34
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 597927, RefRangeEnd = 597929, XrefRangeStart = 597921, XrefRangeEnd = 597927, 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: 0x0600808F RID: 32911 RVA: 0x0020C894 File Offset: 0x0020AA94
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 597929, XrefRangeEnd = 597931, 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: 0x06008090 RID: 32912 RVA: 0x0020C8EC File Offset: 0x0020AAEC
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 597931, XrefRangeEnd = 597941, 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: 0x06008091 RID: 32913 RVA: 0x0020C964 File Offset: 0x0020AB64
		[CallerCount(11)]
		[CachedScanResults(RefRangeStart = 597942, RefRangeEnd = 597953, XrefRangeStart = 597941, XrefRangeEnd = 597942, 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: 0x06008092 RID: 32914 RVA: 0x0020C9B0 File Offset: 0x0020ABB0
		// 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, 100672984);
			IKSolver.NativeMethodInfoPtr_IsValid_Public_Abstract_Virtual_New_Boolean_byref_String_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100672985);
			IKSolver.NativeMethodInfoPtr_Initiate_Public_Void_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100672986);
			IKSolver.NativeMethodInfoPtr_Update_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100672987);
			IKSolver.NativeMethodInfoPtr_GetIKPosition_Public_Virtual_New_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100672988);
			IKSolver.NativeMethodInfoPtr_SetIKPosition_Public_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100672989);
			IKSolver.NativeMethodInfoPtr_GetIKPositionWeight_Public_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100672990);
			IKSolver.NativeMethodInfoPtr_SetIKPositionWeight_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100672991);
			IKSolver.NativeMethodInfoPtr_GetRoot_Public_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100672992);
			IKSolver.NativeMethodInfoPtr_get_initiated_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100672993);
			IKSolver.NativeMethodInfoPtr_set_initiated_Private_set_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100672994);
			IKSolver.NativeMethodInfoPtr_GetPoints_Public_Abstract_Virtual_New_Il2CppReferenceArray_1_Point_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100672995);
			IKSolver.NativeMethodInfoPtr_GetPoint_Public_Abstract_Virtual_New_Point_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100672996);
			IKSolver.NativeMethodInfoPtr_FixTransforms_Public_Abstract_Virtual_New_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100672997);
			IKSolver.NativeMethodInfoPtr_StoreDefaultLocalState_Public_Abstract_Virtual_New_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100672998);
			IKSolver.NativeMethodInfoPtr_OnInitiate_Protected_Abstract_Virtual_New_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100672999);
			IKSolver.NativeMethodInfoPtr_OnUpdate_Protected_Abstract_Virtual_New_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100673000);
			IKSolver.NativeMethodInfoPtr_LogWarning_Protected_Void_String_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100673001);
			IKSolver.NativeMethodInfoPtr_ContainsDuplicateBone_Public_Static_Transform_Il2CppReferenceArray_1_Bone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100673002);
			IKSolver.NativeMethodInfoPtr_HierarchyIsValid_Public_Static_Boolean_Il2CppReferenceArray_1_Bone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100673003);
			IKSolver.NativeMethodInfoPtr_PreSolveBones_Protected_Static_Single_byref_Il2CppReferenceArray_1_Bone_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100673004);
			IKSolver.NativeMethodInfoPtr__ctor_Protected_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver>.NativeClassPtr, 100673005);
		}

		// Token: 0x06008093 RID: 32915 RVA: 0x0000A688 File Offset: 0x00008888
		public IKSolver(IntPtr pointer)
			: base(pointer)
		{
		}

		// Token: 0x17002BD1 RID: 11217
		// (get) Token: 0x06008094 RID: 32916 RVA: 0x0020CC4C File Offset: 0x0020AE4C
		// (set) Token: 0x06008095 RID: 32917 RVA: 0x0020CC74 File Offset: 0x0020AE74
		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: 0x17002BD2 RID: 11218
		// (get) Token: 0x06008096 RID: 32918 RVA: 0x0020CC98 File Offset: 0x0020AE98
		// (set) Token: 0x06008097 RID: 32919 RVA: 0x0020CCC0 File Offset: 0x0020AEC0
		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: 0x17002BD3 RID: 11219
		// (get) Token: 0x06008098 RID: 32920 RVA: 0x0020CCE4 File Offset: 0x0020AEE4
		// (set) Token: 0x06008099 RID: 32921 RVA: 0x0020CD0C File Offset: 0x0020AF0C
		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: 0x17002BD4 RID: 11220
		// (get) Token: 0x0600809A RID: 32922 RVA: 0x0020CD30 File Offset: 0x0020AF30
		// (set) Token: 0x0600809B RID: 32923 RVA: 0x0020CD64 File Offset: 0x0020AF64
		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: 0x17002BD5 RID: 11221
		// (get) Token: 0x0600809C RID: 32924 RVA: 0x0020CD8C File Offset: 0x0020AF8C
		// (set) Token: 0x0600809D RID: 32925 RVA: 0x0020CDC0 File Offset: 0x0020AFC0
		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: 0x17002BD6 RID: 11222
		// (get) Token: 0x0600809E RID: 32926 RVA: 0x0020CDE8 File Offset: 0x0020AFE8
		// (set) Token: 0x0600809F RID: 32927 RVA: 0x0020CE1C File Offset: 0x0020B01C
		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: 0x17002BD7 RID: 11223
		// (get) Token: 0x060080A0 RID: 32928 RVA: 0x0020CE44 File Offset: 0x0020B044
		// (set) Token: 0x060080A1 RID: 32929 RVA: 0x0020CE78 File Offset: 0x0020B078
		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: 0x17002BD8 RID: 11224
		// (get) Token: 0x060080A2 RID: 32930 RVA: 0x0020CEA0 File Offset: 0x0020B0A0
		// (set) Token: 0x060080A3 RID: 32931 RVA: 0x0020CEC8 File Offset: 0x0020B0C8
		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: 0x17002BD9 RID: 11225
		// (get) Token: 0x060080A4 RID: 32932 RVA: 0x0020CEEC File Offset: 0x0020B0EC
		// (set) Token: 0x060080A5 RID: 32933 RVA: 0x0020CF20 File Offset: 0x0020B120
		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: 0x040055B8 RID: 21944
		private static readonly IntPtr NativeFieldInfoPtr_IKPosition;

		// Token: 0x040055B9 RID: 21945
		private static readonly IntPtr NativeFieldInfoPtr_IKPositionWeight;

		// Token: 0x040055BA RID: 21946
		private static readonly IntPtr NativeFieldInfoPtr__initiated_k__BackingField;

		// Token: 0x040055BB RID: 21947
		private static readonly IntPtr NativeFieldInfoPtr_OnPreInitiate;

		// Token: 0x040055BC RID: 21948
		private static readonly IntPtr NativeFieldInfoPtr_OnPostInitiate;

		// Token: 0x040055BD RID: 21949
		private static readonly IntPtr NativeFieldInfoPtr_OnPreUpdate;

		// Token: 0x040055BE RID: 21950
		private static readonly IntPtr NativeFieldInfoPtr_OnPostUpdate;

		// Token: 0x040055BF RID: 21951
		private static readonly IntPtr NativeFieldInfoPtr_firstInitiation;

		// Token: 0x040055C0 RID: 21952
		private static readonly IntPtr NativeFieldInfoPtr_root;

		// Token: 0x040055C1 RID: 21953
		private static readonly IntPtr NativeMethodInfoPtr_IsValid_Public_Boolean_0;

		// Token: 0x040055C2 RID: 21954
		private static readonly IntPtr NativeMethodInfoPtr_IsValid_Public_Abstract_Virtual_New_Boolean_byref_String_0;

		// Token: 0x040055C3 RID: 21955
		private static readonly IntPtr NativeMethodInfoPtr_Initiate_Public_Void_Transform_0;

		// Token: 0x040055C4 RID: 21956
		private static readonly IntPtr NativeMethodInfoPtr_Update_Public_Void_0;

		// Token: 0x040055C5 RID: 21957
		private static readonly IntPtr NativeMethodInfoPtr_GetIKPosition_Public_Virtual_New_Vector3_0;

		// Token: 0x040055C6 RID: 21958
		private static readonly IntPtr NativeMethodInfoPtr_SetIKPosition_Public_Void_Vector3_0;

		// Token: 0x040055C7 RID: 21959
		private static readonly IntPtr NativeMethodInfoPtr_GetIKPositionWeight_Public_Single_0;

		// Token: 0x040055C8 RID: 21960
		private static readonly IntPtr NativeMethodInfoPtr_SetIKPositionWeight_Public_Void_Single_0;

		// Token: 0x040055C9 RID: 21961
		private static readonly IntPtr NativeMethodInfoPtr_GetRoot_Public_Transform_0;

		// Token: 0x040055CA RID: 21962
		private static readonly IntPtr NativeMethodInfoPtr_get_initiated_Public_get_Boolean_0;

		// Token: 0x040055CB RID: 21963
		private static readonly IntPtr NativeMethodInfoPtr_set_initiated_Private_set_Void_Boolean_0;

		// Token: 0x040055CC RID: 21964
		private static readonly IntPtr NativeMethodInfoPtr_GetPoints_Public_Abstract_Virtual_New_Il2CppReferenceArray_1_Point_0;

		// Token: 0x040055CD RID: 21965
		private static readonly IntPtr NativeMethodInfoPtr_GetPoint_Public_Abstract_Virtual_New_Point_Transform_0;

		// Token: 0x040055CE RID: 21966
		private static readonly IntPtr NativeMethodInfoPtr_FixTransforms_Public_Abstract_Virtual_New_Void_0;

		// Token: 0x040055CF RID: 21967
		private static readonly IntPtr NativeMethodInfoPtr_StoreDefaultLocalState_Public_Abstract_Virtual_New_Void_0;

		// Token: 0x040055D0 RID: 21968
		private static readonly IntPtr NativeMethodInfoPtr_OnInitiate_Protected_Abstract_Virtual_New_Void_0;

		// Token: 0x040055D1 RID: 21969
		private static readonly IntPtr NativeMethodInfoPtr_OnUpdate_Protected_Abstract_Virtual_New_Void_0;

		// Token: 0x040055D2 RID: 21970
		private static readonly IntPtr NativeMethodInfoPtr_LogWarning_Protected_Void_String_0;

		// Token: 0x040055D3 RID: 21971
		private static readonly IntPtr NativeMethodInfoPtr_ContainsDuplicateBone_Public_Static_Transform_Il2CppReferenceArray_1_Bone_0;

		// Token: 0x040055D4 RID: 21972
		private static readonly IntPtr NativeMethodInfoPtr_HierarchyIsValid_Public_Static_Boolean_Il2CppReferenceArray_1_Bone_0;

		// Token: 0x040055D5 RID: 21973
		private static readonly IntPtr NativeMethodInfoPtr_PreSolveBones_Protected_Static_Single_byref_Il2CppReferenceArray_1_Bone_0;

		// Token: 0x040055D6 RID: 21974
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Protected_Void_0;

		// Token: 0x02000432 RID: 1074
		[Serializable]
		public class Point : Il2CppSystem.Object
		{
			// Token: 0x060080A6 RID: 32934 RVA: 0x0020CF48 File Offset: 0x0020B148
			[CallerCount(11)]
			[CachedScanResults(RefRangeStart = 597698, RefRangeEnd = 597709, XrefRangeStart = 597696, XrefRangeEnd = 597698, 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: 0x060080A7 RID: 32935 RVA: 0x0020CF8C File Offset: 0x0020B18C
			[CallerCount(11)]
			[CachedScanResults(RefRangeStart = 597715, RefRangeEnd = 597726, XrefRangeStart = 597709, XrefRangeEnd = 597715, 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: 0x060080A8 RID: 32936 RVA: 0x0020CFD0 File Offset: 0x0020B1D0
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 597726, XrefRangeEnd = 597727, 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: 0x060080A9 RID: 32937 RVA: 0x0020D014 File Offset: 0x0020B214
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 597727, XrefRangeEnd = 597728, 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: 0x060080AA RID: 32938 RVA: 0x0020D058 File Offset: 0x0020B258
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 597728, XrefRangeEnd = 597730, 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: 0x060080AB RID: 32939 RVA: 0x0020D09C File Offset: 0x0020B29C
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 597730, XrefRangeEnd = 597732, 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: 0x060080AC RID: 32940 RVA: 0x0020D0E0 File Offset: 0x0020B2E0
			[CallerCount(5)]
			[CachedScanResults(RefRangeStart = 597734, RefRangeEnd = 597739, XrefRangeStart = 597732, XrefRangeEnd = 597734, 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: 0x060080AD RID: 32941 RVA: 0x0020D12C File Offset: 0x0020B32C
			// 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, 100673006);
				IKSolver.Point.NativeMethodInfoPtr_FixTransform_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.Point>.NativeClassPtr, 100673007);
				IKSolver.Point.NativeMethodInfoPtr_UpdateSolverPosition_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.Point>.NativeClassPtr, 100673008);
				IKSolver.Point.NativeMethodInfoPtr_UpdateSolverLocalPosition_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.Point>.NativeClassPtr, 100673009);
				IKSolver.Point.NativeMethodInfoPtr_UpdateSolverState_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.Point>.NativeClassPtr, 100673010);
				IKSolver.Point.NativeMethodInfoPtr_UpdateSolverLocalState_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.Point>.NativeClassPtr, 100673011);
				IKSolver.Point.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.Point>.NativeClassPtr, 100673012);
			}

			// Token: 0x060080AE RID: 32942 RVA: 0x0000A688 File Offset: 0x00008888
			public Point(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002BDB RID: 11227
			// (get) Token: 0x060080AF RID: 32943 RVA: 0x0020D25C File Offset: 0x0020B45C
			// (set) Token: 0x060080B0 RID: 32944 RVA: 0x0020D290 File Offset: 0x0020B490
			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: 0x17002BDC RID: 11228
			// (get) Token: 0x060080B1 RID: 32945 RVA: 0x0020D2B8 File Offset: 0x0020B4B8
			// (set) Token: 0x060080B2 RID: 32946 RVA: 0x0020D2E0 File Offset: 0x0020B4E0
			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: 0x17002BDD RID: 11229
			// (get) Token: 0x060080B3 RID: 32947 RVA: 0x0020D304 File Offset: 0x0020B504
			// (set) Token: 0x060080B4 RID: 32948 RVA: 0x0020D32C File Offset: 0x0020B52C
			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: 0x17002BDE RID: 11230
			// (get) Token: 0x060080B5 RID: 32949 RVA: 0x0020D350 File Offset: 0x0020B550
			// (set) Token: 0x060080B6 RID: 32950 RVA: 0x0020D378 File Offset: 0x0020B578
			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: 0x17002BDF RID: 11231
			// (get) Token: 0x060080B7 RID: 32951 RVA: 0x0020D39C File Offset: 0x0020B59C
			// (set) Token: 0x060080B8 RID: 32952 RVA: 0x0020D3C4 File Offset: 0x0020B5C4
			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: 0x17002BE0 RID: 11232
			// (get) Token: 0x060080B9 RID: 32953 RVA: 0x0020D3E8 File Offset: 0x0020B5E8
			// (set) Token: 0x060080BA RID: 32954 RVA: 0x0020D410 File Offset: 0x0020B610
			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: 0x040055D7 RID: 21975
			private static readonly IntPtr NativeFieldInfoPtr_transform;

			// Token: 0x040055D8 RID: 21976
			private static readonly IntPtr NativeFieldInfoPtr_weight;

			// Token: 0x040055D9 RID: 21977
			private static readonly IntPtr NativeFieldInfoPtr_solverPosition;

			// Token: 0x040055DA RID: 21978
			private static readonly IntPtr NativeFieldInfoPtr_solverRotation;

			// Token: 0x040055DB RID: 21979
			private static readonly IntPtr NativeFieldInfoPtr_defaultLocalPosition;

			// Token: 0x040055DC RID: 21980
			private static readonly IntPtr NativeFieldInfoPtr_defaultLocalRotation;

			// Token: 0x040055DD RID: 21981
			private static readonly IntPtr NativeMethodInfoPtr_StoreDefaultLocalState_Public_Void_0;

			// Token: 0x040055DE RID: 21982
			private static readonly IntPtr NativeMethodInfoPtr_FixTransform_Public_Void_0;

			// Token: 0x040055DF RID: 21983
			private static readonly IntPtr NativeMethodInfoPtr_UpdateSolverPosition_Public_Void_0;

			// Token: 0x040055E0 RID: 21984
			private static readonly IntPtr NativeMethodInfoPtr_UpdateSolverLocalPosition_Public_Void_0;

			// Token: 0x040055E1 RID: 21985
			private static readonly IntPtr NativeMethodInfoPtr_UpdateSolverState_Public_Void_0;

			// Token: 0x040055E2 RID: 21986
			private static readonly IntPtr NativeMethodInfoPtr_UpdateSolverLocalState_Public_Void_0;

			// Token: 0x040055E3 RID: 21987
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
		}

		// Token: 0x02000433 RID: 1075
		[Serializable]
		public class Bone : IKSolver.Point
		{
			// Token: 0x17002BE6 RID: 11238
			// (get) Token: 0x060080BB RID: 32955 RVA: 0x0020D434 File Offset: 0x0020B634
			// (set) Token: 0x060080BC RID: 32956 RVA: 0x0020D48C File Offset: 0x0020B68C
			public unsafe RotationLimit rotationLimit
			{
				[CallerCount(17)]
				[CachedScanResults(RefRangeStart = 597750, RefRangeEnd = 597767, XrefRangeStart = 597739, XrefRangeEnd = 597750, 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 = 597767, XrefRangeEnd = 597772, 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: 0x060080BD RID: 32957 RVA: 0x0020D4E8 File Offset: 0x0020B6E8
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 597784, RefRangeEnd = 597785, XrefRangeStart = 597772, XrefRangeEnd = 597784, 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: 0x060080BE RID: 32958 RVA: 0x0020D550 File Offset: 0x0020B750
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 597785, XrefRangeEnd = 597793, 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: 0x060080BF RID: 32959 RVA: 0x0020D5D4 File Offset: 0x0020B7D4
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 597804, RefRangeEnd = 597805, XrefRangeStart = 597793, XrefRangeEnd = 597804, 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: 0x060080C0 RID: 32960 RVA: 0x0020D63C File Offset: 0x0020B83C
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 597805, XrefRangeEnd = 597806, 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: 0x060080C1 RID: 32961 RVA: 0x0020D680 File Offset: 0x0020B880
			[CallerCount(4)]
			[CachedScanResults(RefRangeStart = 597809, RefRangeEnd = 597813, XrefRangeStart = 597806, XrefRangeEnd = 597809, 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: 0x060080C2 RID: 32962 RVA: 0x0020D6CC File Offset: 0x0020B8CC
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 597813, XrefRangeEnd = 597817, 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: 0x060080C3 RID: 32963 RVA: 0x0020D730 File Offset: 0x0020B930
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 597817, XrefRangeEnd = 597821, 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: 0x060080C4 RID: 32964 RVA: 0x0020D7A8 File Offset: 0x0020B9A8
			// 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, 100673013);
				IKSolver.Bone.NativeMethodInfoPtr_set_rotationLimit_Public_set_Void_RotationLimit_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.Bone>.NativeClassPtr, 100673014);
				IKSolver.Bone.NativeMethodInfoPtr_Swing_Public_Void_Vector3_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.Bone>.NativeClassPtr, 100673015);
				IKSolver.Bone.NativeMethodInfoPtr_SolverSwing_Public_Static_Void_Il2CppReferenceArray_1_Bone_Int32_Vector3_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.Bone>.NativeClassPtr, 100673016);
				IKSolver.Bone.NativeMethodInfoPtr_Swing2D_Public_Void_Vector3_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.Bone>.NativeClassPtr, 100673017);
				IKSolver.Bone.NativeMethodInfoPtr_SetToSolverPosition_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.Bone>.NativeClassPtr, 100673018);
				IKSolver.Bone.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.Bone>.NativeClassPtr, 100673019);
				IKSolver.Bone.NativeMethodInfoPtr__ctor_Public_Void_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.Bone>.NativeClassPtr, 100673020);
				IKSolver.Bone.NativeMethodInfoPtr__ctor_Public_Void_Transform_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.Bone>.NativeClassPtr, 100673021);
			}

			// Token: 0x060080C5 RID: 32965 RVA: 0x0020D8EB File Offset: 0x0020BAEB
			public Bone(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002BE1 RID: 11233
			// (get) Token: 0x060080C6 RID: 32966 RVA: 0x0020D8F4 File Offset: 0x0020BAF4
			// (set) Token: 0x060080C7 RID: 32967 RVA: 0x0020D91C File Offset: 0x0020BB1C
			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: 0x17002BE2 RID: 11234
			// (get) Token: 0x060080C8 RID: 32968 RVA: 0x0020D940 File Offset: 0x0020BB40
			// (set) Token: 0x060080C9 RID: 32969 RVA: 0x0020D968 File Offset: 0x0020BB68
			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: 0x17002BE3 RID: 11235
			// (get) Token: 0x060080CA RID: 32970 RVA: 0x0020D98C File Offset: 0x0020BB8C
			// (set) Token: 0x060080CB RID: 32971 RVA: 0x0020D9B4 File Offset: 0x0020BBB4
			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: 0x17002BE4 RID: 11236
			// (get) Token: 0x060080CC RID: 32972 RVA: 0x0020D9D8 File Offset: 0x0020BBD8
			// (set) Token: 0x060080CD RID: 32973 RVA: 0x0020DA0C File Offset: 0x0020BC0C
			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: 0x17002BE5 RID: 11237
			// (get) Token: 0x060080CE RID: 32974 RVA: 0x0020DA34 File Offset: 0x0020BC34
			// (set) Token: 0x060080CF RID: 32975 RVA: 0x0020DA5C File Offset: 0x0020BC5C
			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: 0x040055E4 RID: 21988
			private static readonly IntPtr NativeFieldInfoPtr_length;

			// Token: 0x040055E5 RID: 21989
			private static readonly IntPtr NativeFieldInfoPtr_sqrMag;

			// Token: 0x040055E6 RID: 21990
			private static readonly IntPtr NativeFieldInfoPtr_axis;

			// Token: 0x040055E7 RID: 21991
			private static readonly IntPtr NativeFieldInfoPtr__rotationLimit;

			// Token: 0x040055E8 RID: 21992
			private static readonly IntPtr NativeFieldInfoPtr_isLimited;

			// Token: 0x040055E9 RID: 21993
			private static readonly IntPtr NativeMethodInfoPtr_get_rotationLimit_Public_get_RotationLimit_0;

			// Token: 0x040055EA RID: 21994
			private static readonly IntPtr NativeMethodInfoPtr_set_rotationLimit_Public_set_Void_RotationLimit_0;

			// Token: 0x040055EB RID: 21995
			private static readonly IntPtr NativeMethodInfoPtr_Swing_Public_Void_Vector3_Single_0;

			// Token: 0x040055EC RID: 21996
			private static readonly IntPtr NativeMethodInfoPtr_SolverSwing_Public_Static_Void_Il2CppReferenceArray_1_Bone_Int32_Vector3_Single_0;

			// Token: 0x040055ED RID: 21997
			private static readonly IntPtr NativeMethodInfoPtr_Swing2D_Public_Void_Vector3_Single_0;

			// Token: 0x040055EE RID: 21998
			private static readonly IntPtr NativeMethodInfoPtr_SetToSolverPosition_Public_Void_0;

			// Token: 0x040055EF RID: 21999
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

			// Token: 0x040055F0 RID: 22000
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_Transform_0;

			// Token: 0x040055F1 RID: 22001
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_Transform_Single_0;
		}

		// Token: 0x02000434 RID: 1076
		[Serializable]
		public class Node : IKSolver.Point
		{
			// Token: 0x060080D0 RID: 32976 RVA: 0x0020DA80 File Offset: 0x0020BC80
			[CallerCount(5)]
			[CachedScanResults(RefRangeStart = 597734, RefRangeEnd = 597739, XrefRangeStart = 597734, XrefRangeEnd = 597739, 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: 0x060080D1 RID: 32977 RVA: 0x0020DACC File Offset: 0x0020BCCC
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 597824, RefRangeEnd = 597826, XrefRangeStart = 597821, XrefRangeEnd = 597824, 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: 0x060080D2 RID: 32978 RVA: 0x0020DB30 File Offset: 0x0020BD30
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 597826, XrefRangeEnd = 597829, 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: 0x060080D3 RID: 32979 RVA: 0x0020DBA8 File Offset: 0x0020BDA8
			// 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, 100673022);
				IKSolver.Node.NativeMethodInfoPtr__ctor_Public_Void_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.Node>.NativeClassPtr, 100673023);
				IKSolver.Node.NativeMethodInfoPtr__ctor_Public_Void_Transform_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.Node>.NativeClassPtr, 100673024);
			}

			// Token: 0x060080D4 RID: 32980 RVA: 0x0020D8EB File Offset: 0x0020BAEB
			public Node(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17002BE7 RID: 11239
			// (get) Token: 0x060080D5 RID: 32981 RVA: 0x0020DC60 File Offset: 0x0020BE60
			// (set) Token: 0x060080D6 RID: 32982 RVA: 0x0020DC88 File Offset: 0x0020BE88
			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: 0x17002BE8 RID: 11240
			// (get) Token: 0x060080D7 RID: 32983 RVA: 0x0020DCAC File Offset: 0x0020BEAC
			// (set) Token: 0x060080D8 RID: 32984 RVA: 0x0020DCD4 File Offset: 0x0020BED4
			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: 0x17002BE9 RID: 11241
			// (get) Token: 0x060080D9 RID: 32985 RVA: 0x0020DCF8 File Offset: 0x0020BEF8
			// (set) Token: 0x060080DA RID: 32986 RVA: 0x0020DD20 File Offset: 0x0020BF20
			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: 0x17002BEA RID: 11242
			// (get) Token: 0x060080DB RID: 32987 RVA: 0x0020DD44 File Offset: 0x0020BF44
			// (set) Token: 0x060080DC RID: 32988 RVA: 0x0020DD6C File Offset: 0x0020BF6C
			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: 0x040055F2 RID: 22002
			private static readonly IntPtr NativeFieldInfoPtr_length;

			// Token: 0x040055F3 RID: 22003
			private static readonly IntPtr NativeFieldInfoPtr_effectorPositionWeight;

			// Token: 0x040055F4 RID: 22004
			private static readonly IntPtr NativeFieldInfoPtr_effectorRotationWeight;

			// Token: 0x040055F5 RID: 22005
			private static readonly IntPtr NativeFieldInfoPtr_offset;

			// Token: 0x040055F6 RID: 22006
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

			// Token: 0x040055F7 RID: 22007
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_Transform_0;

			// Token: 0x040055F8 RID: 22008
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_Transform_Single_0;
		}

		// Token: 0x02000435 RID: 1077
		public sealed class UpdateDelegate : MulticastDelegate
		{
			// Token: 0x060080DD RID: 32989 RVA: 0x0020DD90 File Offset: 0x0020BF90
			[CallerCount(1930)]
			[CachedScanResults(RefRangeStart = 12873, RefRangeEnd = 14803, XrefRangeStart = 12873, XrefRangeEnd = 14803, 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: 0x060080DE RID: 32990 RVA: 0x0020DE08 File Offset: 0x0020C008
			[CallerCount(29)]
			[CachedScanResults(RefRangeStart = 212210, RefRangeEnd = 212239, XrefRangeStart = 212210, XrefRangeEnd = 212239, 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: 0x060080DF RID: 32991 RVA: 0x0020DE4C File Offset: 0x0020C04C
			[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: 0x060080E0 RID: 32992 RVA: 0x0020DED4 File Offset: 0x0020C0D4
			[CallerCount(3)]
			[CachedScanResults(RefRangeStart = 14814, RefRangeEnd = 14817, XrefRangeStart = 14814, XrefRangeEnd = 14817, 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: 0x060080E1 RID: 32993 RVA: 0x0020DF30 File Offset: 0x0020C130
			// 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, 100673025);
				IKSolver.UpdateDelegate.NativeMethodInfoPtr_Invoke_Public_Virtual_New_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.UpdateDelegate>.NativeClassPtr, 100673026);
				IKSolver.UpdateDelegate.NativeMethodInfoPtr_BeginInvoke_Public_Virtual_New_IAsyncResult_AsyncCallback_Object_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.UpdateDelegate>.NativeClassPtr, 100673027);
				IKSolver.UpdateDelegate.NativeMethodInfoPtr_EndInvoke_Public_Virtual_New_Void_IAsyncResult_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.UpdateDelegate>.NativeClassPtr, 100673028);
			}

			// Token: 0x060080E2 RID: 32994 RVA: 0x00018FBD File Offset: 0x000171BD
			public UpdateDelegate(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x060080E3 RID: 32995 RVA: 0x0020DFA1 File Offset: 0x0020C1A1
			public static implicit operator IKSolver.UpdateDelegate(Action A_0)
			{
				return DelegateSupport.ConvertDelegate<IKSolver.UpdateDelegate>(A_0);
			}

			// Token: 0x060080E4 RID: 32996 RVA: 0x0020DFA9 File Offset: 0x0020C1A9
			public static IKSolver.UpdateDelegate operator +(IKSolver.UpdateDelegate A_0, IKSolver.UpdateDelegate A_1)
			{
				return Delegate.Combine(A_0, A_1).Cast<IKSolver.UpdateDelegate>();
			}

			// Token: 0x060080E5 RID: 32997 RVA: 0x0020DFB7 File Offset: 0x0020C1B7
			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: 0x040055F9 RID: 22009
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_Object_IntPtr_0;

			// Token: 0x040055FA RID: 22010
			private static readonly IntPtr NativeMethodInfoPtr_Invoke_Public_Virtual_New_Void_0;

			// Token: 0x040055FB RID: 22011
			private static readonly IntPtr NativeMethodInfoPtr_BeginInvoke_Public_Virtual_New_IAsyncResult_AsyncCallback_Object_0;

			// Token: 0x040055FC RID: 22012
			private static readonly IntPtr NativeMethodInfoPtr_EndInvoke_Public_Virtual_New_Void_IAsyncResult_0;
		}

		// Token: 0x02000436 RID: 1078
		public sealed class IterationDelegate : MulticastDelegate
		{
			// Token: 0x060080E6 RID: 32998 RVA: 0x0020DFC8 File Offset: 0x0020C1C8
			[CallerCount(1930)]
			[CachedScanResults(RefRangeStart = 12873, RefRangeEnd = 14803, XrefRangeStart = 12873, XrefRangeEnd = 14803, 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: 0x060080E7 RID: 32999 RVA: 0x0020E040 File Offset: 0x0020C240
			[CallerCount(15)]
			[CachedScanResults(RefRangeStart = 210023, RefRangeEnd = 210038, XrefRangeStart = 210023, XrefRangeEnd = 210038, 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: 0x060080E8 RID: 33000 RVA: 0x0020E094 File Offset: 0x0020C294
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 597829, XrefRangeEnd = 597833, 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: 0x060080E9 RID: 33001 RVA: 0x0020E12C File Offset: 0x0020C32C
			[CallerCount(3)]
			[CachedScanResults(RefRangeStart = 14814, RefRangeEnd = 14817, XrefRangeStart = 14814, XrefRangeEnd = 14817, 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: 0x060080EA RID: 33002 RVA: 0x0020E188 File Offset: 0x0020C388
			// 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, 100673029);
				IKSolver.IterationDelegate.NativeMethodInfoPtr_Invoke_Public_Virtual_New_Void_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.IterationDelegate>.NativeClassPtr, 100673030);
				IKSolver.IterationDelegate.NativeMethodInfoPtr_BeginInvoke_Public_Virtual_New_IAsyncResult_Int32_AsyncCallback_Object_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.IterationDelegate>.NativeClassPtr, 100673031);
				IKSolver.IterationDelegate.NativeMethodInfoPtr_EndInvoke_Public_Virtual_New_Void_IAsyncResult_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<IKSolver.IterationDelegate>.NativeClassPtr, 100673032);
			}

			// Token: 0x060080EB RID: 33003 RVA: 0x00018FBD File Offset: 0x000171BD
			public IterationDelegate(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x060080EC RID: 33004 RVA: 0x0020E1F9 File Offset: 0x0020C3F9
			public static implicit operator IKSolver.IterationDelegate(Action<int> A_0)
			{
				return DelegateSupport.ConvertDelegate<IKSolver.IterationDelegate>(A_0);
			}

			// Token: 0x060080ED RID: 33005 RVA: 0x0020E201 File Offset: 0x0020C401
			public static IKSolver.IterationDelegate operator +(IKSolver.IterationDelegate A_0, IKSolver.IterationDelegate A_1)
			{
				return Delegate.Combine(A_0, A_1).Cast<IKSolver.IterationDelegate>();
			}

			// Token: 0x060080EE RID: 33006 RVA: 0x0020E20F File Offset: 0x0020C40F
			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: 0x040055FD RID: 22013
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_Object_IntPtr_0;

			// Token: 0x040055FE RID: 22014
			private static readonly IntPtr NativeMethodInfoPtr_Invoke_Public_Virtual_New_Void_Int32_0;

			// Token: 0x040055FF RID: 22015
			private static readonly IntPtr NativeMethodInfoPtr_BeginInvoke_Public_Virtual_New_IAsyncResult_Int32_AsyncCallback_Object_0;

			// Token: 0x04005600 RID: 22016
			private static readonly IntPtr NativeMethodInfoPtr_EndInvoke_Public_Virtual_New_Void_IAsyncResult_0;
		}
	}
}
