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

namespace RootMotion
{
	// Token: 0x02000403 RID: 1027
	public class Interp : Il2CppSystem.Object
	{
		// Token: 0x06007DC8 RID: 32200 RVA: 0x00202150 File Offset: 0x00200350
		[CallerCount(6)]
		[CachedScanResults(RefRangeStart = 623183, RefRangeEnd = 623189, XrefRangeStart = 623183, XrefRangeEnd = 623183, 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: 0x06007DC9 RID: 32201 RVA: 0x002021B8 File Offset: 0x002003B8
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 623189, XrefRangeEnd = 623190, 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: 0x06007DCA RID: 32202 RVA: 0x00202244 File Offset: 0x00200444
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 623194, RefRangeEnd = 623196, XrefRangeStart = 623190, XrefRangeEnd = 623194, 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: 0x06007DCB RID: 32203 RVA: 0x002022D0 File Offset: 0x002004D0
		[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: 0x06007DCC RID: 32204 RVA: 0x0020234C File Offset: 0x0020054C
		[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: 0x06007DCD RID: 32205 RVA: 0x002023C8 File Offset: 0x002005C8
		[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: 0x06007DCE RID: 32206 RVA: 0x00202444 File Offset: 0x00200644
		[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: 0x06007DCF RID: 32207 RVA: 0x002024C0 File Offset: 0x002006C0
		[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: 0x06007DD0 RID: 32208 RVA: 0x0020253C File Offset: 0x0020073C
		[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: 0x06007DD1 RID: 32209 RVA: 0x002025B8 File Offset: 0x002007B8
		[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: 0x06007DD2 RID: 32210 RVA: 0x00202634 File Offset: 0x00200834
		[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: 0x06007DD3 RID: 32211 RVA: 0x002026B0 File Offset: 0x002008B0
		[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: 0x06007DD4 RID: 32212 RVA: 0x0020272C File Offset: 0x0020092C
		[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: 0x06007DD5 RID: 32213 RVA: 0x002027A8 File Offset: 0x002009A8
		[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: 0x06007DD6 RID: 32214 RVA: 0x00202824 File Offset: 0x00200A24
		[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: 0x06007DD7 RID: 32215 RVA: 0x002028A0 File Offset: 0x00200AA0
		[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: 0x06007DD8 RID: 32216 RVA: 0x0020291C File Offset: 0x00200B1C
		[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: 0x06007DD9 RID: 32217 RVA: 0x00202998 File Offset: 0x00200B98
		[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: 0x06007DDA RID: 32218 RVA: 0x00202A14 File Offset: 0x00200C14
		[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: 0x06007DDB RID: 32219 RVA: 0x00202A90 File Offset: 0x00200C90
		[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: 0x06007DDC RID: 32220 RVA: 0x00202B0C File Offset: 0x00200D0C
		[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: 0x06007DDD RID: 32221 RVA: 0x00202B88 File Offset: 0x00200D88
		[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: 0x06007DDE RID: 32222 RVA: 0x00202C04 File Offset: 0x00200E04
		[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: 0x06007DDF RID: 32223 RVA: 0x00202C80 File Offset: 0x00200E80
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 623196, XrefRangeEnd = 623197, 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: 0x06007DE0 RID: 32224 RVA: 0x00202CFC File Offset: 0x00200EFC
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 623197, XrefRangeEnd = 623198, 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: 0x06007DE1 RID: 32225 RVA: 0x00202D78 File Offset: 0x00200F78
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 623198, XrefRangeEnd = 623199, 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: 0x06007DE2 RID: 32226 RVA: 0x00202DF4 File Offset: 0x00200FF4
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 623199, XrefRangeEnd = 623202, 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: 0x06007DE3 RID: 32227 RVA: 0x00202E70 File Offset: 0x00201070
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 623202, XrefRangeEnd = 623205, 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: 0x06007DE4 RID: 32228 RVA: 0x00202EEC File Offset: 0x002010EC
		[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: 0x06007DE5 RID: 32229 RVA: 0x00202F68 File Offset: 0x00201168
		[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: 0x06007DE6 RID: 32230 RVA: 0x00202FE4 File Offset: 0x002011E4
		[CallerCount(1664)]
		[CachedScanResults(RefRangeStart = 7711, RefRangeEnd = 9375, XrefRangeStart = 7711, XrefRangeEnd = 9375, 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: 0x06007DE7 RID: 32231 RVA: 0x00203030 File Offset: 0x00201230
		// 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, 100672867);
			Interp.NativeMethodInfoPtr_V3_Public_Static_Vector3_Vector3_Vector3_Single_InterpolationMode_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672868);
			Interp.NativeMethodInfoPtr_LerpValue_Public_Static_Single_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672869);
			Interp.NativeMethodInfoPtr_None_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672870);
			Interp.NativeMethodInfoPtr_InOutCubic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672871);
			Interp.NativeMethodInfoPtr_InOutQuintic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672872);
			Interp.NativeMethodInfoPtr_InQuintic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672873);
			Interp.NativeMethodInfoPtr_InQuartic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672874);
			Interp.NativeMethodInfoPtr_InCubic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672875);
			Interp.NativeMethodInfoPtr_InQuadratic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672876);
			Interp.NativeMethodInfoPtr_OutQuintic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672877);
			Interp.NativeMethodInfoPtr_OutQuartic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672878);
			Interp.NativeMethodInfoPtr_OutCubic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672879);
			Interp.NativeMethodInfoPtr_OutInCubic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672880);
			Interp.NativeMethodInfoPtr_OutInQuartic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672881);
			Interp.NativeMethodInfoPtr_BackInCubic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672882);
			Interp.NativeMethodInfoPtr_BackInQuartic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672883);
			Interp.NativeMethodInfoPtr_OutBackCubic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672884);
			Interp.NativeMethodInfoPtr_OutBackQuartic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672885);
			Interp.NativeMethodInfoPtr_OutElasticSmall_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672886);
			Interp.NativeMethodInfoPtr_OutElasticBig_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672887);
			Interp.NativeMethodInfoPtr_InElasticSmall_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672888);
			Interp.NativeMethodInfoPtr_InElasticBig_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672889);
			Interp.NativeMethodInfoPtr_InSine_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672890);
			Interp.NativeMethodInfoPtr_OutSine_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672891);
			Interp.NativeMethodInfoPtr_InOutSine_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672892);
			Interp.NativeMethodInfoPtr_InElastic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672893);
			Interp.NativeMethodInfoPtr_OutElastic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672894);
			Interp.NativeMethodInfoPtr_InBack_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672895);
			Interp.NativeMethodInfoPtr_OutBack_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672896);
			Interp.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672897);
		}

		// Token: 0x06007DE8 RID: 32232 RVA: 0x0000A74C File Offset: 0x0000894C
		public Interp(IntPtr pointer)
			: base(pointer)
		{
		}

		// Token: 0x0400549B RID: 21659
		private static readonly IntPtr NativeMethodInfoPtr_Float_Public_Static_Single_Single_InterpolationMode_0;

		// Token: 0x0400549C RID: 21660
		private static readonly IntPtr NativeMethodInfoPtr_V3_Public_Static_Vector3_Vector3_Vector3_Single_InterpolationMode_0;

		// Token: 0x0400549D RID: 21661
		private static readonly IntPtr NativeMethodInfoPtr_LerpValue_Public_Static_Single_Single_Single_Single_Single_0;

		// Token: 0x0400549E RID: 21662
		private static readonly IntPtr NativeMethodInfoPtr_None_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x0400549F RID: 21663
		private static readonly IntPtr NativeMethodInfoPtr_InOutCubic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x040054A0 RID: 21664
		private static readonly IntPtr NativeMethodInfoPtr_InOutQuintic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x040054A1 RID: 21665
		private static readonly IntPtr NativeMethodInfoPtr_InQuintic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x040054A2 RID: 21666
		private static readonly IntPtr NativeMethodInfoPtr_InQuartic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x040054A3 RID: 21667
		private static readonly IntPtr NativeMethodInfoPtr_InCubic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x040054A4 RID: 21668
		private static readonly IntPtr NativeMethodInfoPtr_InQuadratic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x040054A5 RID: 21669
		private static readonly IntPtr NativeMethodInfoPtr_OutQuintic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x040054A6 RID: 21670
		private static readonly IntPtr NativeMethodInfoPtr_OutQuartic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x040054A7 RID: 21671
		private static readonly IntPtr NativeMethodInfoPtr_OutCubic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x040054A8 RID: 21672
		private static readonly IntPtr NativeMethodInfoPtr_OutInCubic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x040054A9 RID: 21673
		private static readonly IntPtr NativeMethodInfoPtr_OutInQuartic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x040054AA RID: 21674
		private static readonly IntPtr NativeMethodInfoPtr_BackInCubic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x040054AB RID: 21675
		private static readonly IntPtr NativeMethodInfoPtr_BackInQuartic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x040054AC RID: 21676
		private static readonly IntPtr NativeMethodInfoPtr_OutBackCubic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x040054AD RID: 21677
		private static readonly IntPtr NativeMethodInfoPtr_OutBackQuartic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x040054AE RID: 21678
		private static readonly IntPtr NativeMethodInfoPtr_OutElasticSmall_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x040054AF RID: 21679
		private static readonly IntPtr NativeMethodInfoPtr_OutElasticBig_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x040054B0 RID: 21680
		private static readonly IntPtr NativeMethodInfoPtr_InElasticSmall_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x040054B1 RID: 21681
		private static readonly IntPtr NativeMethodInfoPtr_InElasticBig_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x040054B2 RID: 21682
		private static readonly IntPtr NativeMethodInfoPtr_InSine_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x040054B3 RID: 21683
		private static readonly IntPtr NativeMethodInfoPtr_OutSine_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x040054B4 RID: 21684
		private static readonly IntPtr NativeMethodInfoPtr_InOutSine_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x040054B5 RID: 21685
		private static readonly IntPtr NativeMethodInfoPtr_InElastic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x040054B6 RID: 21686
		private static readonly IntPtr NativeMethodInfoPtr_OutElastic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x040054B7 RID: 21687
		private static readonly IntPtr NativeMethodInfoPtr_InBack_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x040054B8 RID: 21688
		private static readonly IntPtr NativeMethodInfoPtr_OutBack_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x040054B9 RID: 21689
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
	}
}
