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

namespace RootMotion
{
	// Token: 0x020003AB RID: 939
	public class Interp : Il2CppSystem.Object
	{
		// Token: 0x06007575 RID: 30069 RVA: 0x001DF414 File Offset: 0x001DD614
		[CallerCount(6)]
		[CachedScanResults(RefRangeStart = 590878, RefRangeEnd = 590884, XrefRangeStart = 590878, XrefRangeEnd = 590878, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe static float Float(float t, InterpolationMode mode)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref t;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref mode;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Interp.NativeMethodInfoPtr_Float_Public_Static_Single_Single_InterpolationMode_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x06007576 RID: 30070 RVA: 0x001DF47C File Offset: 0x001DD67C
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 590884, XrefRangeEnd = 590885, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe static Vector3 V3(Vector3 v1, Vector3 v2, float t, InterpolationMode mode)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref v1;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref v2;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref t;
			ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref mode;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Interp.NativeMethodInfoPtr_V3_Public_Static_Vector3_Vector3_Vector3_Single_InterpolationMode_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x06007577 RID: 30071 RVA: 0x001DF508 File Offset: 0x001DD708
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 590889, RefRangeEnd = 590891, XrefRangeStart = 590885, XrefRangeEnd = 590889, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe static float LerpValue(float value, float target, float increaseSpeed, float decreaseSpeed)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref value;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref target;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref increaseSpeed;
			ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref decreaseSpeed;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Interp.NativeMethodInfoPtr_LerpValue_Public_Static_Single_Single_Single_Single_Single_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x06007578 RID: 30072 RVA: 0x001DF594 File Offset: 0x001DD794
		[CallerCount(0)]
		public unsafe static float None(float t, float b, float c)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref t;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref b;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref c;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Interp.NativeMethodInfoPtr_None_Private_Static_Single_Single_Single_Single_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x06007579 RID: 30073 RVA: 0x001DF610 File Offset: 0x001DD810
		[CallerCount(0)]
		public unsafe static float InOutCubic(float t, float b, float c)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref t;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref b;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref c;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Interp.NativeMethodInfoPtr_InOutCubic_Private_Static_Single_Single_Single_Single_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x0600757A RID: 30074 RVA: 0x001DF68C File Offset: 0x001DD88C
		[CallerCount(0)]
		public unsafe static float InOutQuintic(float t, float b, float c)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref t;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref b;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref c;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Interp.NativeMethodInfoPtr_InOutQuintic_Private_Static_Single_Single_Single_Single_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x0600757B RID: 30075 RVA: 0x001DF708 File Offset: 0x001DD908
		[CallerCount(0)]
		public unsafe static float InQuintic(float t, float b, float c)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref t;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref b;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref c;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Interp.NativeMethodInfoPtr_InQuintic_Private_Static_Single_Single_Single_Single_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x0600757C RID: 30076 RVA: 0x001DF784 File Offset: 0x001DD984
		[CallerCount(0)]
		public unsafe static float InQuartic(float t, float b, float c)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref t;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref b;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref c;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Interp.NativeMethodInfoPtr_InQuartic_Private_Static_Single_Single_Single_Single_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x0600757D RID: 30077 RVA: 0x001DF800 File Offset: 0x001DDA00
		[CallerCount(0)]
		public unsafe static float InCubic(float t, float b, float c)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref t;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref b;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref c;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Interp.NativeMethodInfoPtr_InCubic_Private_Static_Single_Single_Single_Single_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x0600757E RID: 30078 RVA: 0x001DF87C File Offset: 0x001DDA7C
		[CallerCount(0)]
		public unsafe static float InQuadratic(float t, float b, float c)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref t;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref b;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref c;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Interp.NativeMethodInfoPtr_InQuadratic_Private_Static_Single_Single_Single_Single_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x0600757F RID: 30079 RVA: 0x001DF8F8 File Offset: 0x001DDAF8
		[CallerCount(0)]
		public unsafe static float OutQuintic(float t, float b, float c)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref t;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref b;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref c;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Interp.NativeMethodInfoPtr_OutQuintic_Private_Static_Single_Single_Single_Single_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x06007580 RID: 30080 RVA: 0x001DF974 File Offset: 0x001DDB74
		[CallerCount(0)]
		public unsafe static float OutQuartic(float t, float b, float c)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref t;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref b;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref c;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Interp.NativeMethodInfoPtr_OutQuartic_Private_Static_Single_Single_Single_Single_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x06007581 RID: 30081 RVA: 0x001DF9F0 File Offset: 0x001DDBF0
		[CallerCount(0)]
		public unsafe static float OutCubic(float t, float b, float c)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref t;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref b;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref c;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Interp.NativeMethodInfoPtr_OutCubic_Private_Static_Single_Single_Single_Single_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x06007582 RID: 30082 RVA: 0x001DFA6C File Offset: 0x001DDC6C
		[CallerCount(0)]
		public unsafe static float OutInCubic(float t, float b, float c)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref t;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref b;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref c;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Interp.NativeMethodInfoPtr_OutInCubic_Private_Static_Single_Single_Single_Single_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x06007583 RID: 30083 RVA: 0x001DFAE8 File Offset: 0x001DDCE8
		[CallerCount(0)]
		public unsafe static float OutInQuartic(float t, float b, float c)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref t;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref b;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref c;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Interp.NativeMethodInfoPtr_OutInQuartic_Private_Static_Single_Single_Single_Single_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x06007584 RID: 30084 RVA: 0x001DFB64 File Offset: 0x001DDD64
		[CallerCount(0)]
		public unsafe static float BackInCubic(float t, float b, float c)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref t;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref b;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref c;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Interp.NativeMethodInfoPtr_BackInCubic_Private_Static_Single_Single_Single_Single_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x06007585 RID: 30085 RVA: 0x001DFBE0 File Offset: 0x001DDDE0
		[CallerCount(0)]
		public unsafe static float BackInQuartic(float t, float b, float c)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref t;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref b;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref c;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Interp.NativeMethodInfoPtr_BackInQuartic_Private_Static_Single_Single_Single_Single_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x06007586 RID: 30086 RVA: 0x001DFC5C File Offset: 0x001DDE5C
		[CallerCount(0)]
		public unsafe static float OutBackCubic(float t, float b, float c)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref t;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref b;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref c;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Interp.NativeMethodInfoPtr_OutBackCubic_Private_Static_Single_Single_Single_Single_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x06007587 RID: 30087 RVA: 0x001DFCD8 File Offset: 0x001DDED8
		[CallerCount(0)]
		public unsafe static float OutBackQuartic(float t, float b, float c)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref t;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref b;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref c;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Interp.NativeMethodInfoPtr_OutBackQuartic_Private_Static_Single_Single_Single_Single_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x06007588 RID: 30088 RVA: 0x001DFD54 File Offset: 0x001DDF54
		[CallerCount(0)]
		public unsafe static float OutElasticSmall(float t, float b, float c)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref t;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref b;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref c;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Interp.NativeMethodInfoPtr_OutElasticSmall_Private_Static_Single_Single_Single_Single_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x06007589 RID: 30089 RVA: 0x001DFDD0 File Offset: 0x001DDFD0
		[CallerCount(0)]
		public unsafe static float OutElasticBig(float t, float b, float c)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref t;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref b;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref c;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Interp.NativeMethodInfoPtr_OutElasticBig_Private_Static_Single_Single_Single_Single_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x0600758A RID: 30090 RVA: 0x001DFE4C File Offset: 0x001DE04C
		[CallerCount(0)]
		public unsafe static float InElasticSmall(float t, float b, float c)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref t;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref b;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref c;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Interp.NativeMethodInfoPtr_InElasticSmall_Private_Static_Single_Single_Single_Single_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x0600758B RID: 30091 RVA: 0x001DFEC8 File Offset: 0x001DE0C8
		[CallerCount(0)]
		public unsafe static float InElasticBig(float t, float b, float c)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref t;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref b;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref c;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Interp.NativeMethodInfoPtr_InElasticBig_Private_Static_Single_Single_Single_Single_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x0600758C RID: 30092 RVA: 0x001DFF44 File Offset: 0x001DE144
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 590891, XrefRangeEnd = 590892, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe static float InSine(float t, float b, float c)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref t;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref b;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref c;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Interp.NativeMethodInfoPtr_InSine_Private_Static_Single_Single_Single_Single_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x0600758D RID: 30093 RVA: 0x001DFFC0 File Offset: 0x001DE1C0
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 590892, XrefRangeEnd = 590893, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe static float OutSine(float t, float b, float c)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref t;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref b;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref c;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Interp.NativeMethodInfoPtr_OutSine_Private_Static_Single_Single_Single_Single_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x0600758E RID: 30094 RVA: 0x001E003C File Offset: 0x001DE23C
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 590893, XrefRangeEnd = 590894, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe static float InOutSine(float t, float b, float c)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref t;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref b;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref c;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Interp.NativeMethodInfoPtr_InOutSine_Private_Static_Single_Single_Single_Single_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x0600758F RID: 30095 RVA: 0x001E00B8 File Offset: 0x001DE2B8
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 590894, XrefRangeEnd = 590897, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe static float InElastic(float t, float b, float c)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref t;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref b;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref c;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Interp.NativeMethodInfoPtr_InElastic_Private_Static_Single_Single_Single_Single_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x06007590 RID: 30096 RVA: 0x001E0134 File Offset: 0x001DE334
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 590897, XrefRangeEnd = 590900, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe static float OutElastic(float t, float b, float c)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref t;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref b;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref c;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Interp.NativeMethodInfoPtr_OutElastic_Private_Static_Single_Single_Single_Single_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x06007591 RID: 30097 RVA: 0x001E01B0 File Offset: 0x001DE3B0
		[CallerCount(0)]
		public unsafe static float InBack(float t, float b, float c)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref t;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref b;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref c;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Interp.NativeMethodInfoPtr_InBack_Private_Static_Single_Single_Single_Single_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x06007592 RID: 30098 RVA: 0x001E022C File Offset: 0x001DE42C
		[CallerCount(0)]
		public unsafe static float OutBack(float t, float b, float c)
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref t;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref b;
			ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref c;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Interp.NativeMethodInfoPtr_OutBack_Private_Static_Single_Single_Single_Single_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x06007593 RID: 30099 RVA: 0x001E02A8 File Offset: 0x001DE4A8
		[CallerCount(1642)]
		[CachedScanResults(RefRangeStart = 7417, RefRangeEnd = 9059, XrefRangeStart = 7417, XrefRangeEnd = 9059, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe Interp()
			: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<Interp>.NativeClassPtr))
		{
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(Interp.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06007594 RID: 30100 RVA: 0x001E02F4 File Offset: 0x001DE4F4
		// Note: this type is marked as 'beforefieldinit'.
		static Interp()
		{
			Il2CppClassPointerStore<Interp>.NativeClassPtr = IL2CPP.GetIl2CppClass("Assembly-CSharp.dll", "RootMotion", "Interp");
			IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<Interp>.NativeClassPtr);
			Interp.NativeMethodInfoPtr_Float_Public_Static_Single_Single_InterpolationMode_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672154);
			Interp.NativeMethodInfoPtr_V3_Public_Static_Vector3_Vector3_Vector3_Single_InterpolationMode_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672155);
			Interp.NativeMethodInfoPtr_LerpValue_Public_Static_Single_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672156);
			Interp.NativeMethodInfoPtr_None_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672157);
			Interp.NativeMethodInfoPtr_InOutCubic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672158);
			Interp.NativeMethodInfoPtr_InOutQuintic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672159);
			Interp.NativeMethodInfoPtr_InQuintic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672160);
			Interp.NativeMethodInfoPtr_InQuartic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672161);
			Interp.NativeMethodInfoPtr_InCubic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672162);
			Interp.NativeMethodInfoPtr_InQuadratic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672163);
			Interp.NativeMethodInfoPtr_OutQuintic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672164);
			Interp.NativeMethodInfoPtr_OutQuartic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672165);
			Interp.NativeMethodInfoPtr_OutCubic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672166);
			Interp.NativeMethodInfoPtr_OutInCubic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672167);
			Interp.NativeMethodInfoPtr_OutInQuartic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672168);
			Interp.NativeMethodInfoPtr_BackInCubic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672169);
			Interp.NativeMethodInfoPtr_BackInQuartic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672170);
			Interp.NativeMethodInfoPtr_OutBackCubic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672171);
			Interp.NativeMethodInfoPtr_OutBackQuartic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672172);
			Interp.NativeMethodInfoPtr_OutElasticSmall_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672173);
			Interp.NativeMethodInfoPtr_OutElasticBig_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672174);
			Interp.NativeMethodInfoPtr_InElasticSmall_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672175);
			Interp.NativeMethodInfoPtr_InElasticBig_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672176);
			Interp.NativeMethodInfoPtr_InSine_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672177);
			Interp.NativeMethodInfoPtr_OutSine_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672178);
			Interp.NativeMethodInfoPtr_InOutSine_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672179);
			Interp.NativeMethodInfoPtr_InElastic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672180);
			Interp.NativeMethodInfoPtr_OutElastic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672181);
			Interp.NativeMethodInfoPtr_InBack_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672182);
			Interp.NativeMethodInfoPtr_OutBack_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672183);
			Interp.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672184);
		}

		// Token: 0x06007595 RID: 30101 RVA: 0x0000A688 File Offset: 0x00008888
		public Interp(IntPtr pointer)
			: base(pointer)
		{
		}

		// Token: 0x04004EF2 RID: 20210
		private static readonly IntPtr NativeMethodInfoPtr_Float_Public_Static_Single_Single_InterpolationMode_0;

		// Token: 0x04004EF3 RID: 20211
		private static readonly IntPtr NativeMethodInfoPtr_V3_Public_Static_Vector3_Vector3_Vector3_Single_InterpolationMode_0;

		// Token: 0x04004EF4 RID: 20212
		private static readonly IntPtr NativeMethodInfoPtr_LerpValue_Public_Static_Single_Single_Single_Single_Single_0;

		// Token: 0x04004EF5 RID: 20213
		private static readonly IntPtr NativeMethodInfoPtr_None_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004EF6 RID: 20214
		private static readonly IntPtr NativeMethodInfoPtr_InOutCubic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004EF7 RID: 20215
		private static readonly IntPtr NativeMethodInfoPtr_InOutQuintic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004EF8 RID: 20216
		private static readonly IntPtr NativeMethodInfoPtr_InQuintic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004EF9 RID: 20217
		private static readonly IntPtr NativeMethodInfoPtr_InQuartic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004EFA RID: 20218
		private static readonly IntPtr NativeMethodInfoPtr_InCubic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004EFB RID: 20219
		private static readonly IntPtr NativeMethodInfoPtr_InQuadratic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004EFC RID: 20220
		private static readonly IntPtr NativeMethodInfoPtr_OutQuintic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004EFD RID: 20221
		private static readonly IntPtr NativeMethodInfoPtr_OutQuartic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004EFE RID: 20222
		private static readonly IntPtr NativeMethodInfoPtr_OutCubic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004EFF RID: 20223
		private static readonly IntPtr NativeMethodInfoPtr_OutInCubic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F00 RID: 20224
		private static readonly IntPtr NativeMethodInfoPtr_OutInQuartic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F01 RID: 20225
		private static readonly IntPtr NativeMethodInfoPtr_BackInCubic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F02 RID: 20226
		private static readonly IntPtr NativeMethodInfoPtr_BackInQuartic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F03 RID: 20227
		private static readonly IntPtr NativeMethodInfoPtr_OutBackCubic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F04 RID: 20228
		private static readonly IntPtr NativeMethodInfoPtr_OutBackQuartic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F05 RID: 20229
		private static readonly IntPtr NativeMethodInfoPtr_OutElasticSmall_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F06 RID: 20230
		private static readonly IntPtr NativeMethodInfoPtr_OutElasticBig_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F07 RID: 20231
		private static readonly IntPtr NativeMethodInfoPtr_InElasticSmall_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F08 RID: 20232
		private static readonly IntPtr NativeMethodInfoPtr_InElasticBig_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F09 RID: 20233
		private static readonly IntPtr NativeMethodInfoPtr_InSine_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F0A RID: 20234
		private static readonly IntPtr NativeMethodInfoPtr_OutSine_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F0B RID: 20235
		private static readonly IntPtr NativeMethodInfoPtr_InOutSine_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F0C RID: 20236
		private static readonly IntPtr NativeMethodInfoPtr_InElastic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F0D RID: 20237
		private static readonly IntPtr NativeMethodInfoPtr_OutElastic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F0E RID: 20238
		private static readonly IntPtr NativeMethodInfoPtr_InBack_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F0F RID: 20239
		private static readonly IntPtr NativeMethodInfoPtr_OutBack_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F10 RID: 20240
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
	}
}
