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

namespace RootMotion
{
	// Token: 0x020003B4 RID: 948
	public class Interp : Il2CppSystem.Object
	{
		// Token: 0x06007625 RID: 30245 RVA: 0x001E2018 File Offset: 0x001E0218
		[CallerCount(6)]
		[CachedScanResults(RefRangeStart = 608485, RefRangeEnd = 608491, XrefRangeStart = 608485, XrefRangeEnd = 608485, 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: 0x06007626 RID: 30246 RVA: 0x001E2080 File Offset: 0x001E0280
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 608491, XrefRangeEnd = 608492, 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: 0x06007627 RID: 30247 RVA: 0x001E210C File Offset: 0x001E030C
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 608496, RefRangeEnd = 608498, XrefRangeStart = 608492, XrefRangeEnd = 608496, 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: 0x06007628 RID: 30248 RVA: 0x001E2198 File Offset: 0x001E0398
		[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: 0x06007629 RID: 30249 RVA: 0x001E2214 File Offset: 0x001E0414
		[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: 0x0600762A RID: 30250 RVA: 0x001E2290 File Offset: 0x001E0490
		[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: 0x0600762B RID: 30251 RVA: 0x001E230C File Offset: 0x001E050C
		[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: 0x0600762C RID: 30252 RVA: 0x001E2388 File Offset: 0x001E0588
		[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: 0x0600762D RID: 30253 RVA: 0x001E2404 File Offset: 0x001E0604
		[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: 0x0600762E RID: 30254 RVA: 0x001E2480 File Offset: 0x001E0680
		[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: 0x0600762F RID: 30255 RVA: 0x001E24FC File Offset: 0x001E06FC
		[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: 0x06007630 RID: 30256 RVA: 0x001E2578 File Offset: 0x001E0778
		[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: 0x06007631 RID: 30257 RVA: 0x001E25F4 File Offset: 0x001E07F4
		[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: 0x06007632 RID: 30258 RVA: 0x001E2670 File Offset: 0x001E0870
		[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: 0x06007633 RID: 30259 RVA: 0x001E26EC File Offset: 0x001E08EC
		[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: 0x06007634 RID: 30260 RVA: 0x001E2768 File Offset: 0x001E0968
		[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: 0x06007635 RID: 30261 RVA: 0x001E27E4 File Offset: 0x001E09E4
		[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: 0x06007636 RID: 30262 RVA: 0x001E2860 File Offset: 0x001E0A60
		[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: 0x06007637 RID: 30263 RVA: 0x001E28DC File Offset: 0x001E0ADC
		[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: 0x06007638 RID: 30264 RVA: 0x001E2958 File Offset: 0x001E0B58
		[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: 0x06007639 RID: 30265 RVA: 0x001E29D4 File Offset: 0x001E0BD4
		[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: 0x0600763A RID: 30266 RVA: 0x001E2A50 File Offset: 0x001E0C50
		[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: 0x0600763B RID: 30267 RVA: 0x001E2ACC File Offset: 0x001E0CCC
		[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: 0x0600763C RID: 30268 RVA: 0x001E2B48 File Offset: 0x001E0D48
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 608498, XrefRangeEnd = 608499, 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: 0x0600763D RID: 30269 RVA: 0x001E2BC4 File Offset: 0x001E0DC4
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 608499, XrefRangeEnd = 608500, 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: 0x0600763E RID: 30270 RVA: 0x001E2C40 File Offset: 0x001E0E40
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 608500, XrefRangeEnd = 608501, 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: 0x0600763F RID: 30271 RVA: 0x001E2CBC File Offset: 0x001E0EBC
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 608501, XrefRangeEnd = 608504, 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: 0x06007640 RID: 30272 RVA: 0x001E2D38 File Offset: 0x001E0F38
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 608504, XrefRangeEnd = 608507, 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: 0x06007641 RID: 30273 RVA: 0x001E2DB4 File Offset: 0x001E0FB4
		[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: 0x06007642 RID: 30274 RVA: 0x001E2E30 File Offset: 0x001E1030
		[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: 0x06007643 RID: 30275 RVA: 0x001E2EAC File Offset: 0x001E10AC
		[CallerCount(1659)]
		[CachedScanResults(RefRangeStart = 7639, RefRangeEnd = 9298, XrefRangeStart = 7639, XrefRangeEnd = 9298, 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: 0x06007644 RID: 30276 RVA: 0x001E2EF8 File Offset: 0x001E10F8
		// 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, 100672204);
			Interp.NativeMethodInfoPtr_V3_Public_Static_Vector3_Vector3_Vector3_Single_InterpolationMode_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672205);
			Interp.NativeMethodInfoPtr_LerpValue_Public_Static_Single_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672206);
			Interp.NativeMethodInfoPtr_None_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672207);
			Interp.NativeMethodInfoPtr_InOutCubic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672208);
			Interp.NativeMethodInfoPtr_InOutQuintic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672209);
			Interp.NativeMethodInfoPtr_InQuintic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672210);
			Interp.NativeMethodInfoPtr_InQuartic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672211);
			Interp.NativeMethodInfoPtr_InCubic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672212);
			Interp.NativeMethodInfoPtr_InQuadratic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672213);
			Interp.NativeMethodInfoPtr_OutQuintic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672214);
			Interp.NativeMethodInfoPtr_OutQuartic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672215);
			Interp.NativeMethodInfoPtr_OutCubic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672216);
			Interp.NativeMethodInfoPtr_OutInCubic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672217);
			Interp.NativeMethodInfoPtr_OutInQuartic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672218);
			Interp.NativeMethodInfoPtr_BackInCubic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672219);
			Interp.NativeMethodInfoPtr_BackInQuartic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672220);
			Interp.NativeMethodInfoPtr_OutBackCubic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672221);
			Interp.NativeMethodInfoPtr_OutBackQuartic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672222);
			Interp.NativeMethodInfoPtr_OutElasticSmall_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672223);
			Interp.NativeMethodInfoPtr_OutElasticBig_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672224);
			Interp.NativeMethodInfoPtr_InElasticSmall_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672225);
			Interp.NativeMethodInfoPtr_InElasticBig_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672226);
			Interp.NativeMethodInfoPtr_InSine_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672227);
			Interp.NativeMethodInfoPtr_OutSine_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672228);
			Interp.NativeMethodInfoPtr_InOutSine_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672229);
			Interp.NativeMethodInfoPtr_InElastic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672230);
			Interp.NativeMethodInfoPtr_OutElastic_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672231);
			Interp.NativeMethodInfoPtr_InBack_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672232);
			Interp.NativeMethodInfoPtr_OutBack_Private_Static_Single_Single_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672233);
			Interp.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<Interp>.NativeClassPtr, 100672234);
		}

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

		// Token: 0x04004F66 RID: 20326
		private static readonly IntPtr NativeMethodInfoPtr_Float_Public_Static_Single_Single_InterpolationMode_0;

		// Token: 0x04004F67 RID: 20327
		private static readonly IntPtr NativeMethodInfoPtr_V3_Public_Static_Vector3_Vector3_Vector3_Single_InterpolationMode_0;

		// Token: 0x04004F68 RID: 20328
		private static readonly IntPtr NativeMethodInfoPtr_LerpValue_Public_Static_Single_Single_Single_Single_Single_0;

		// Token: 0x04004F69 RID: 20329
		private static readonly IntPtr NativeMethodInfoPtr_None_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F6A RID: 20330
		private static readonly IntPtr NativeMethodInfoPtr_InOutCubic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F6B RID: 20331
		private static readonly IntPtr NativeMethodInfoPtr_InOutQuintic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F6C RID: 20332
		private static readonly IntPtr NativeMethodInfoPtr_InQuintic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F6D RID: 20333
		private static readonly IntPtr NativeMethodInfoPtr_InQuartic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F6E RID: 20334
		private static readonly IntPtr NativeMethodInfoPtr_InCubic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F6F RID: 20335
		private static readonly IntPtr NativeMethodInfoPtr_InQuadratic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F70 RID: 20336
		private static readonly IntPtr NativeMethodInfoPtr_OutQuintic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F71 RID: 20337
		private static readonly IntPtr NativeMethodInfoPtr_OutQuartic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F72 RID: 20338
		private static readonly IntPtr NativeMethodInfoPtr_OutCubic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F73 RID: 20339
		private static readonly IntPtr NativeMethodInfoPtr_OutInCubic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F74 RID: 20340
		private static readonly IntPtr NativeMethodInfoPtr_OutInQuartic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F75 RID: 20341
		private static readonly IntPtr NativeMethodInfoPtr_BackInCubic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F76 RID: 20342
		private static readonly IntPtr NativeMethodInfoPtr_BackInQuartic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F77 RID: 20343
		private static readonly IntPtr NativeMethodInfoPtr_OutBackCubic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F78 RID: 20344
		private static readonly IntPtr NativeMethodInfoPtr_OutBackQuartic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F79 RID: 20345
		private static readonly IntPtr NativeMethodInfoPtr_OutElasticSmall_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F7A RID: 20346
		private static readonly IntPtr NativeMethodInfoPtr_OutElasticBig_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F7B RID: 20347
		private static readonly IntPtr NativeMethodInfoPtr_InElasticSmall_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F7C RID: 20348
		private static readonly IntPtr NativeMethodInfoPtr_InElasticBig_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F7D RID: 20349
		private static readonly IntPtr NativeMethodInfoPtr_InSine_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F7E RID: 20350
		private static readonly IntPtr NativeMethodInfoPtr_OutSine_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F7F RID: 20351
		private static readonly IntPtr NativeMethodInfoPtr_InOutSine_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F80 RID: 20352
		private static readonly IntPtr NativeMethodInfoPtr_InElastic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F81 RID: 20353
		private static readonly IntPtr NativeMethodInfoPtr_OutElastic_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F82 RID: 20354
		private static readonly IntPtr NativeMethodInfoPtr_InBack_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F83 RID: 20355
		private static readonly IntPtr NativeMethodInfoPtr_OutBack_Private_Static_Single_Single_Single_Single_0;

		// Token: 0x04004F84 RID: 20356
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
	}
}