NobetaSource/Interop/Assembly-CSharp/NobetaAnimatorController.cs

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

// Token: 0x0200031E RID: 798
[Serializable]
public class NobetaAnimatorController : Il2CppSystem.Object
{
	// Token: 0x06006B49 RID: 27465 RVA: 0x001B2C18 File Offset: 0x001B0E18
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 598220, RefRangeEnd = 598221, XrefRangeStart = 598218, XrefRangeEnd = 598220, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void Init(Animator main, Animator face)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = IL2CPP.Il2CppObjectBaseToPtr(main);
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(face);
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr_Init_Public_Void_Animator_Animator_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006B4A RID: 27466 RVA: 0x001B2C8C File Offset: 0x001B0E8C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 598285, RefRangeEnd = 598286, XrefRangeStart = 598221, XrefRangeEnd = 598285, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void Update(NobetaAnimatorData data)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = IL2CPP.Il2CppObjectBaseToPtr(data);
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr_Update_Public_Void_NobetaAnimatorData_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06006B4B RID: 27467 RVA: 0x001B2CE8 File Offset: 0x001B0EE8
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 598288, RefRangeEnd = 598289, XrefRangeStart = 598286, XrefRangeEnd = 598288, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void PlayBraking()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr_PlayBraking_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006B4C RID: 27468 RVA: 0x001B2D2C File Offset: 0x001B0F2C
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 598290, RefRangeEnd = 598292, XrefRangeStart = 598289, XrefRangeEnd = 598290, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void PlayDodgeForward()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr_PlayDodgeForward_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006B4D RID: 27469 RVA: 0x001B2D70 File Offset: 0x001B0F70
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 598293, RefRangeEnd = 598295, XrefRangeStart = 598292, XrefRangeEnd = 598293, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void PlayDodgeBack()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr_PlayDodgeBack_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006B4E RID: 27470 RVA: 0x001B2DB4 File Offset: 0x001B0FB4
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 598298, RefRangeEnd = 598300, XrefRangeStart = 598295, XrefRangeEnd = 598298, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void PlayJump(float duration, float startTime)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref duration;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref startTime;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr_PlayJump_Public_Void_Single_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006B4F RID: 27471 RVA: 0x001B2E1C File Offset: 0x001B101C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 598303, RefRangeEnd = 598304, XrefRangeStart = 598300, XrefRangeEnd = 598303, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void PlaySkyJump(float duration, float startTime)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref duration;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref startTime;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr_PlaySkyJump_Public_Void_Single_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006B50 RID: 27472 RVA: 0x001B2E84 File Offset: 0x001B1084
	[CallerCount(13)]
	[CachedScanResults(RefRangeStart = 598306, RefRangeEnd = 598319, XrefRangeStart = 598304, XrefRangeEnd = 598306, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void PlayFall()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr_PlayFall_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006B51 RID: 27473 RVA: 0x001B2EC8 File Offset: 0x001B10C8
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 598323, RefRangeEnd = 598324, XrefRangeStart = 598319, XrefRangeEnd = 598323, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void PlayLand(bool isHighlyLand)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref isHighlyLand;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr_PlayLand_Public_Void_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06006B52 RID: 27474 RVA: 0x001B2F1C File Offset: 0x001B111C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 598329, RefRangeEnd = 598330, XrefRangeStart = 598324, XrefRangeEnd = 598329, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void PlayPickUp()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr_PlayPickUp_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006B53 RID: 27475 RVA: 0x001B2F60 File Offset: 0x001B1160
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 598335, RefRangeEnd = 598336, XrefRangeStart = 598330, XrefRangeEnd = 598335, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void PlayDiscardItem()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr_PlayDiscardItem_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006B54 RID: 27476 RVA: 0x001B2FA4 File Offset: 0x001B11A4
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 598342, RefRangeEnd = 598343, XrefRangeStart = 598336, XrefRangeEnd = 598342, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void PlayOnLight()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr_PlayOnLight_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006B55 RID: 27477 RVA: 0x001B2FE8 File Offset: 0x001B11E8
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 598349, RefRangeEnd = 598350, XrefRangeStart = 598343, XrefRangeEnd = 598349, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void PlayLightBall()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr_PlayLightBall_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006B56 RID: 27478 RVA: 0x001B302C File Offset: 0x001B122C
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 598350, XrefRangeEnd = 598355, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void PlaySwitchOn()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr_PlaySwitchOn_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006B57 RID: 27479 RVA: 0x001B3070 File Offset: 0x001B1270
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 598357, RefRangeEnd = 598359, XrefRangeStart = 598355, XrefRangeEnd = 598357, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void PlayPrayerStart()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr_PlayPrayerStart_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006B58 RID: 27480 RVA: 0x001B30B4 File Offset: 0x001B12B4
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 598365, RefRangeEnd = 598367, XrefRangeStart = 598359, XrefRangeEnd = 598365, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void PlayPrayerEnd()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr_PlayPrayerEnd_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006B59 RID: 27481 RVA: 0x001B30F8 File Offset: 0x001B12F8
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 598369, RefRangeEnd = 598370, XrefRangeStart = 598367, XrefRangeEnd = 598369, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void PlayFire()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr_PlayFire_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006B5A RID: 27482 RVA: 0x001B313C File Offset: 0x001B133C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 598372, RefRangeEnd = 598373, XrefRangeStart = 598370, XrefRangeEnd = 598372, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void PlayNullFire()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr_PlayNullFire_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006B5B RID: 27483 RVA: 0x001B3180 File Offset: 0x001B1380
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 598374, RefRangeEnd = 598375, XrefRangeStart = 598373, XrefRangeEnd = 598374, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void PlayNormalFire()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr_PlayNormalFire_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006B5C RID: 27484 RVA: 0x001B31C4 File Offset: 0x001B13C4
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 598375, XrefRangeEnd = 598379, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void ResumeNoneBattleState()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr_ResumeNoneBattleState_Private_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006B5D RID: 27485 RVA: 0x001B3208 File Offset: 0x001B1408
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 598380, RefRangeEnd = 598382, XrefRangeStart = 598379, XrefRangeEnd = 598380, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void SetFireWeightZero()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr_SetFireWeightZero_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006B5E RID: 27486 RVA: 0x001B324C File Offset: 0x001B144C
	[CallerCount(23)]
	[CachedScanResults(RefRangeStart = 598387, RefRangeEnd = 598410, XrefRangeStart = 598382, XrefRangeEnd = 598387, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void SetMoveSpeed(float value, bool isSmooth = true)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref value;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref isSmooth;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr_SetMoveSpeed_Public_Void_Single_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006B5F RID: 27487 RVA: 0x001B32B4 File Offset: 0x001B14B4
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 598413, RefRangeEnd = 598414, XrefRangeStart = 598410, XrefRangeEnd = 598413, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void SetScriptMoveSpeed(float value)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref value;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr_SetScriptMoveSpeed_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06006B60 RID: 27488 RVA: 0x001B3308 File Offset: 0x001B1508
	[CallerCount(19)]
	[CachedScanResults(RefRangeStart = 598417, RefRangeEnd = 598436, XrefRangeStart = 598414, XrefRangeEnd = 598417, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void SetBattleStatus(bool isBattleState)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref isBattleState;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr_SetBattleStatus_Public_Void_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06006B61 RID: 27489 RVA: 0x001B335C File Offset: 0x001B155C
	[CallerCount(0)]
	public unsafe bool GetBattleStatus()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr_GetBattleStatus_Public_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x06006B62 RID: 27490 RVA: 0x001B33AC File Offset: 0x001B15AC
	[CallerCount(21)]
	[CachedScanResults(RefRangeStart = 598437, RefRangeEnd = 598458, XrefRangeStart = 598436, XrefRangeEnd = 598437, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void SetCharge(bool isCharge)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref isCharge;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr_SetCharge_Public_Void_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06006B63 RID: 27491 RVA: 0x001B3400 File Offset: 0x001B1600
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 598458, RefRangeEnd = 598459, XrefRangeStart = 598458, XrefRangeEnd = 598458, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe bool GetCharge()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr_GetCharge_Public_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x06006B64 RID: 27492 RVA: 0x001B3450 File Offset: 0x001B1650
	[CallerCount(5)]
	[CachedScanResults(RefRangeStart = 598460, RefRangeEnd = 598465, XrefRangeStart = 598459, XrefRangeEnd = 598460, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void SetUseItem(bool isUseItem)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref isUseItem;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr_SetUseItem_Public_Void_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06006B65 RID: 27493 RVA: 0x001B34A4 File Offset: 0x001B16A4
	[CallerCount(0)]
	public unsafe bool GetUseItem()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr_GetUseItem_Public_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x06006B66 RID: 27494 RVA: 0x001B34F4 File Offset: 0x001B16F4
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 598468, RefRangeEnd = 598469, XrefRangeStart = 598465, XrefRangeEnd = 598468, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void SetTimeScale(float timeScale)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref timeScale;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr_SetTimeScale_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06006B67 RID: 27495 RVA: 0x001B3548 File Offset: 0x001B1748
	[CallerCount(9)]
	[CachedScanResults(RefRangeStart = 7466, RefRangeEnd = 7475, XrefRangeStart = 7466, XrefRangeEnd = 7475, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe Animator GetAnimator()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr_GetAnimator_Public_Animator_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		IntPtr intPtr3 = intPtr;
		return (intPtr3 != 0) ? new Animator(intPtr3) : null;
	}

	// Token: 0x06006B68 RID: 27496 RVA: 0x001B35A0 File Offset: 0x001B17A0
	[CallerCount(10)]
	[CachedScanResults(RefRangeStart = 7455, RefRangeEnd = 7465, XrefRangeStart = 7455, XrefRangeEnd = 7465, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe Animator GetFaceAnimator()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr_GetFaceAnimator_Public_Animator_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		IntPtr intPtr3 = intPtr;
		return (intPtr3 != 0) ? new Animator(intPtr3) : null;
	}

	// Token: 0x06006B69 RID: 27497 RVA: 0x001B35F8 File Offset: 0x001B17F8
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 223830, RefRangeEnd = 223831, XrefRangeStart = 223830, XrefRangeEnd = 223831, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void SetAimWeight(float value)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref value;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr_SetAimWeight_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06006B6A RID: 27498 RVA: 0x001B364C File Offset: 0x001B184C
	[CallerCount(0)]
	public unsafe void SetNorFireWeight(float value)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref value;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr_SetNorFireWeight_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06006B6B RID: 27499 RVA: 0x001B36A0 File Offset: 0x001B18A0
	[CallerCount(0)]
	public unsafe void SetHoldShot(float value)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref value;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr_SetHoldShot_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06006B6C RID: 27500 RVA: 0x001B36F4 File Offset: 0x001B18F4
	[CallerCount(0)]
	public unsafe float GetNorFireWeight()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr_GetNorFireWeight_Public_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return *IL2CPP.il2cpp_object_unbox(intPtr);
	}

	// Token: 0x06006B6D RID: 27501 RVA: 0x001B3744 File Offset: 0x001B1944
	[CallerCount(22)]
	[CachedScanResults(RefRangeStart = 598471, RefRangeEnd = 598493, XrefRangeStart = 598469, XrefRangeEnd = 598471, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void SetNorFireWeightZero()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr_SetNorFireWeightZero_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006B6E RID: 27502 RVA: 0x001B3788 File Offset: 0x001B1988
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 598497, RefRangeEnd = 598498, XrefRangeStart = 598493, XrefRangeEnd = 598497, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void SetFear(bool isFear)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref isFear;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr_SetFear_Public_Void_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06006B6F RID: 27503 RVA: 0x001B37DC File Offset: 0x001B19DC
	[CallerCount(0)]
	public unsafe void SetHeadHeight(float value)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref value;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr_SetHeadHeight_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06006B70 RID: 27504 RVA: 0x001B3830 File Offset: 0x001B1A30
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 598501, RefRangeEnd = 598505, XrefRangeStart = 598498, XrefRangeEnd = 598501, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void SetSpeakLayerWeight(bool enable, int id = 0)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref enable;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref id;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr_SetSpeakLayerWeight_Public_Void_Boolean_Int32_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006B71 RID: 27505 RVA: 0x001B3898 File Offset: 0x001B1A98
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 598508, RefRangeEnd = 598510, XrefRangeStart = 598505, XrefRangeEnd = 598508, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void SetWindLayer(bool enable)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref enable;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr_SetWindLayer_Public_Void_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06006B72 RID: 27506 RVA: 0x001B38EC File Offset: 0x001B1AEC
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 598515, RefRangeEnd = 598516, XrefRangeStart = 598510, XrefRangeEnd = 598515, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void SetPreyAnimation()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr_SetPreyAnimation_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006B73 RID: 27507 RVA: 0x001B3930 File Offset: 0x001B1B30
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 598658, RefRangeEnd = 598659, XrefRangeStart = 598516, XrefRangeEnd = 598658, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe NobetaAnimatorController()
		: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr))
	{
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaAnimatorController.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006B74 RID: 27508 RVA: 0x001B397C File Offset: 0x001B1B7C
	// Note: this type is marked as 'beforefieldinit'.
	static NobetaAnimatorController()
	{
		Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr = IL2CPP.GetIl2CppClass("Assembly-CSharp.dll", "", "NobetaAnimatorController");
		IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr);
		NobetaAnimatorController.NativeFieldInfoPtr_mainAnimator = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "mainAnimator");
		NobetaAnimatorController.NativeFieldInfoPtr_faceAnimator = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "faceAnimator");
		NobetaAnimatorController.NativeFieldInfoPtr_aimWeight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "aimWeight");
		NobetaAnimatorController.NativeFieldInfoPtr_aimReadyWeight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "aimReadyWeight");
		NobetaAnimatorController.NativeFieldInfoPtr_fireLayerWeight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "fireLayerWeight");
		NobetaAnimatorController.NativeFieldInfoPtr_fireLayerStayTime = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "fireLayerStayTime");
		NobetaAnimatorController.NativeFieldInfoPtr_moveSpeed = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "moveSpeed");
		NobetaAnimatorController.NativeFieldInfoPtr_moveAngle = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "moveAngle");
		NobetaAnimatorController.NativeFieldInfoPtr_moveHorizontal = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "moveHorizontal");
		NobetaAnimatorController.NativeFieldInfoPtr_moveVertical = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "moveVertical");
		NobetaAnimatorController.NativeFieldInfoPtr_scriptMovement = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "scriptMovement");
		NobetaAnimatorController.NativeFieldInfoPtr_isBattleState = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "isBattleState");
		NobetaAnimatorController.NativeFieldInfoPtr_battleTime = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "battleTime");
		NobetaAnimatorController.NativeFieldInfoPtr_isIdleRandom = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "isIdleRandom");
		NobetaAnimatorController.NativeFieldInfoPtr_idleTime = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "idleTime");
		NobetaAnimatorController.NativeFieldInfoPtr_battleFace = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "battleFace");
		NobetaAnimatorController.NativeFieldInfoPtr_skyStayTime = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "skyStayTime");
		NobetaAnimatorController.NativeFieldInfoPtr_norFireWeight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "norFireWeight");
		NobetaAnimatorController.NativeFieldInfoPtr_norFireStayTime = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "norFireStayTime");
		NobetaAnimatorController.NativeFieldInfoPtr_charge = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "charge");
		NobetaAnimatorController.NativeFieldInfoPtr_chargeValue = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "chargeValue");
		NobetaAnimatorController.NativeFieldInfoPtr_useItem = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "useItem");
		NobetaAnimatorController.NativeFieldInfoPtr_useItemValue = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "useItemValue");
		NobetaAnimatorController.NativeFieldInfoPtr_holdShot = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "holdShot");
		NobetaAnimatorController.NativeFieldInfoPtr_norFireAngle = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "norFireAngle");
		NobetaAnimatorController.NativeFieldInfoPtr_act01IdleHead = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "act01IdleHead");
		NobetaAnimatorController.NativeFieldInfoPtr_act01IdleHeadSet = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "act01IdleHeadSet");
		NobetaAnimatorController.NativeFieldInfoPtr_windLayerEnable = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "windLayerEnable");
		NobetaAnimatorController.NativeFieldInfoPtr_windLayerWeight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "windLayerWeight");
		NobetaAnimatorController.NativeFieldInfoPtr_timeScale = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "timeScale");
		NobetaAnimatorController.NativeFieldInfoPtr_battleTimeMax = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "battleTimeMax");
		NobetaAnimatorController.NativeFieldInfoPtr_IdleTimeMax = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "IdleTimeMax");
		NobetaAnimatorController.NativeFieldInfoPtr_switchIdleStateHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "switchIdleStateHash");
		NobetaAnimatorController.NativeFieldInfoPtr_idleRandom01StateHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "idleRandom01StateHash");
		NobetaAnimatorController.NativeFieldInfoPtr_idleRandom02StateHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "idleRandom02StateHash");
		NobetaAnimatorController.NativeFieldInfoPtr_brakingBattleStateHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "brakingBattleStateHash");
		NobetaAnimatorController.NativeFieldInfoPtr_brakingStateHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "brakingStateHash");
		NobetaAnimatorController.NativeFieldInfoPtr_dodgeForwardStateHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "dodgeForwardStateHash");
		NobetaAnimatorController.NativeFieldInfoPtr_dodgeBackwardStateHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "dodgeBackwardStateHash");
		NobetaAnimatorController.NativeFieldInfoPtr_heightLandBattleStateHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "heightLandBattleStateHash");
		NobetaAnimatorController.NativeFieldInfoPtr_heightLandStateHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "heightLandStateHash");
		NobetaAnimatorController.NativeFieldInfoPtr_landBattleStateHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "landBattleStateHash");
		NobetaAnimatorController.NativeFieldInfoPtr_landStateHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "landStateHash");
		NobetaAnimatorController.NativeFieldInfoPtr_pickUpStateHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "pickUpStateHash");
		NobetaAnimatorController.NativeFieldInfoPtr_discardItemStateHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "discardItemStateHash");
		NobetaAnimatorController.NativeFieldInfoPtr_lightUpStateHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "lightUpStateHash");
		NobetaAnimatorController.NativeFieldInfoPtr_stage4LightBallStateHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "stage4LightBallStateHash");
		NobetaAnimatorController.NativeFieldInfoPtr_switchOnStateHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "switchOnStateHash");
		NobetaAnimatorController.NativeFieldInfoPtr_idleToPrayStateHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "idleToPrayStateHash");
		NobetaAnimatorController.NativeFieldInfoPtr_idleToPrayHeadUpStateHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "idleToPrayHeadUpStateHash");
		NobetaAnimatorController.NativeFieldInfoPtr_preyToIdleStateHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "preyToIdleStateHash");
		NobetaAnimatorController.NativeFieldInfoPtr_idleStateHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "idleStateHash");
		NobetaAnimatorController.NativeFieldInfoPtr_aimShotStateHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "aimShotStateHash");
		NobetaAnimatorController.NativeFieldInfoPtr_aimNullShotStateHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "aimNullShotStateHash");
		NobetaAnimatorController.NativeFieldInfoPtr_jumpBattleStateHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "jumpBattleStateHash");
		NobetaAnimatorController.NativeFieldInfoPtr_jumpStateHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "jumpStateHash");
		NobetaAnimatorController.NativeFieldInfoPtr_skyJumpBattleStateHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "skyJumpBattleStateHash");
		NobetaAnimatorController.NativeFieldInfoPtr_skyJumpStateHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "skyJumpStateHash");
		NobetaAnimatorController.NativeFieldInfoPtr_fallBattleStateHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "fallBattleStateHash");
		NobetaAnimatorController.NativeFieldInfoPtr_fallStateHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "fallStateHash");
		NobetaAnimatorController.NativeFieldInfoPtr_speakNormalStateHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "speakNormalStateHash");
		NobetaAnimatorController.NativeFieldInfoPtr_speakHappyStateHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "speakHappyStateHash");
		NobetaAnimatorController.NativeFieldInfoPtr_speakLoudlyStateHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "speakLoudlyStateHash");
		NobetaAnimatorController.NativeFieldInfoPtr_moveSpeedHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "moveSpeedHash");
		NobetaAnimatorController.NativeFieldInfoPtr_fearHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "fearHash");
		NobetaAnimatorController.NativeFieldInfoPtr_moveAngleHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "moveAngleHash");
		NobetaAnimatorController.NativeFieldInfoPtr_moveHorizontalHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "moveHorizontalHash");
		NobetaAnimatorController.NativeFieldInfoPtr_moveVerticalHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "moveVerticalHash");
		NobetaAnimatorController.NativeFieldInfoPtr_isSkyHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "isSkyHash");
		NobetaAnimatorController.NativeFieldInfoPtr_aimReadyHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "aimReadyHash");
		NobetaAnimatorController.NativeFieldInfoPtr_aimHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "aimHash");
		NobetaAnimatorController.NativeFieldInfoPtr_isBattleHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "isBattleHash");
		NobetaAnimatorController.NativeFieldInfoPtr_battleHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "battleHash");
		NobetaAnimatorController.NativeFieldInfoPtr_norFireAngleHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "norFireAngleHash");
		NobetaAnimatorController.NativeFieldInfoPtr_chargeHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "chargeHash");
		NobetaAnimatorController.NativeFieldInfoPtr_useItemHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "useItemHash");
		NobetaAnimatorController.NativeFieldInfoPtr_chargeMaxHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "chargeMaxHash");
		NobetaAnimatorController.NativeFieldInfoPtr_holdShotHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "holdShotHash");
		NobetaAnimatorController.NativeFieldInfoPtr_act01IdleHeadHash = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, "act01IdleHeadHash");
		NobetaAnimatorController.NativeMethodInfoPtr_Init_Public_Void_Animator_Animator_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671161);
		NobetaAnimatorController.NativeMethodInfoPtr_Update_Public_Void_NobetaAnimatorData_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671162);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayBraking_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671163);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayDodgeForward_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671164);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayDodgeBack_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671165);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayJump_Public_Void_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671166);
		NobetaAnimatorController.NativeMethodInfoPtr_PlaySkyJump_Public_Void_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671167);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayFall_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671168);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayLand_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671169);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayPickUp_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671170);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayDiscardItem_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671171);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayOnLight_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671172);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayLightBall_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671173);
		NobetaAnimatorController.NativeMethodInfoPtr_PlaySwitchOn_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671174);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayPrayerStart_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671175);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayPrayerEnd_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671176);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayFire_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671177);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayNullFire_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671178);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayNormalFire_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671179);
		NobetaAnimatorController.NativeMethodInfoPtr_ResumeNoneBattleState_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671180);
		NobetaAnimatorController.NativeMethodInfoPtr_SetFireWeightZero_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671181);
		NobetaAnimatorController.NativeMethodInfoPtr_SetMoveSpeed_Public_Void_Single_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671182);
		NobetaAnimatorController.NativeMethodInfoPtr_SetScriptMoveSpeed_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671183);
		NobetaAnimatorController.NativeMethodInfoPtr_SetBattleStatus_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671184);
		NobetaAnimatorController.NativeMethodInfoPtr_GetBattleStatus_Public_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671185);
		NobetaAnimatorController.NativeMethodInfoPtr_SetCharge_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671186);
		NobetaAnimatorController.NativeMethodInfoPtr_GetCharge_Public_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671187);
		NobetaAnimatorController.NativeMethodInfoPtr_SetUseItem_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671188);
		NobetaAnimatorController.NativeMethodInfoPtr_GetUseItem_Public_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671189);
		NobetaAnimatorController.NativeMethodInfoPtr_SetTimeScale_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671190);
		NobetaAnimatorController.NativeMethodInfoPtr_GetAnimator_Public_Animator_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671191);
		NobetaAnimatorController.NativeMethodInfoPtr_GetFaceAnimator_Public_Animator_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671192);
		NobetaAnimatorController.NativeMethodInfoPtr_SetAimWeight_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671193);
		NobetaAnimatorController.NativeMethodInfoPtr_SetNorFireWeight_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671194);
		NobetaAnimatorController.NativeMethodInfoPtr_SetHoldShot_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671195);
		NobetaAnimatorController.NativeMethodInfoPtr_GetNorFireWeight_Public_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671196);
		NobetaAnimatorController.NativeMethodInfoPtr_SetNorFireWeightZero_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671197);
		NobetaAnimatorController.NativeMethodInfoPtr_SetFear_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671198);
		NobetaAnimatorController.NativeMethodInfoPtr_SetHeadHeight_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671199);
		NobetaAnimatorController.NativeMethodInfoPtr_SetSpeakLayerWeight_Public_Void_Boolean_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671200);
		NobetaAnimatorController.NativeMethodInfoPtr_SetWindLayer_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671201);
		NobetaAnimatorController.NativeMethodInfoPtr_SetPreyAnimation_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671202);
		NobetaAnimatorController.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671203);
	}

	// Token: 0x06006B75 RID: 27509 RVA: 0x0000A74C File Offset: 0x0000894C
	public NobetaAnimatorController(IntPtr pointer)
		: base(pointer)
	{
	}

	// Token: 0x17002538 RID: 9528
	// (get) Token: 0x06006B76 RID: 27510 RVA: 0x001B4334 File Offset: 0x001B2534
	// (set) Token: 0x06006B77 RID: 27511 RVA: 0x001B4368 File Offset: 0x001B2568
	public unsafe Animator mainAnimator
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_mainAnimator);
			IntPtr intPtr2 = *intPtr;
			return (intPtr2 != 0) ? new Animator(intPtr2) : null;
		}
		set
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_mainAnimator), IL2CPP.Il2CppObjectBaseToPtr(value));
		}
	}

	// Token: 0x17002539 RID: 9529
	// (get) Token: 0x06006B78 RID: 27512 RVA: 0x001B4390 File Offset: 0x001B2590
	// (set) Token: 0x06006B79 RID: 27513 RVA: 0x001B43C4 File Offset: 0x001B25C4
	public unsafe Animator faceAnimator
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_faceAnimator);
			IntPtr intPtr2 = *intPtr;
			return (intPtr2 != 0) ? new Animator(intPtr2) : null;
		}
		set
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_faceAnimator), IL2CPP.Il2CppObjectBaseToPtr(value));
		}
	}

	// Token: 0x1700253A RID: 9530
	// (get) Token: 0x06006B7A RID: 27514 RVA: 0x001B43EC File Offset: 0x001B25EC
	// (set) Token: 0x06006B7B RID: 27515 RVA: 0x001B4414 File Offset: 0x001B2614
	public unsafe float aimWeight
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_aimWeight);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_aimWeight)) = value;
		}
	}

	// Token: 0x1700253B RID: 9531
	// (get) Token: 0x06006B7C RID: 27516 RVA: 0x001B4438 File Offset: 0x001B2638
	// (set) Token: 0x06006B7D RID: 27517 RVA: 0x001B4460 File Offset: 0x001B2660
	public unsafe float aimReadyWeight
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_aimReadyWeight);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_aimReadyWeight)) = value;
		}
	}

	// Token: 0x1700253C RID: 9532
	// (get) Token: 0x06006B7E RID: 27518 RVA: 0x001B4484 File Offset: 0x001B2684
	// (set) Token: 0x06006B7F RID: 27519 RVA: 0x001B44AC File Offset: 0x001B26AC
	public unsafe float fireLayerWeight
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_fireLayerWeight);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_fireLayerWeight)) = value;
		}
	}

	// Token: 0x1700253D RID: 9533
	// (get) Token: 0x06006B80 RID: 27520 RVA: 0x001B44D0 File Offset: 0x001B26D0
	// (set) Token: 0x06006B81 RID: 27521 RVA: 0x001B44F8 File Offset: 0x001B26F8
	public unsafe float fireLayerStayTime
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_fireLayerStayTime);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_fireLayerStayTime)) = value;
		}
	}

	// Token: 0x1700253E RID: 9534
	// (get) Token: 0x06006B82 RID: 27522 RVA: 0x001B451C File Offset: 0x001B271C
	// (set) Token: 0x06006B83 RID: 27523 RVA: 0x001B4544 File Offset: 0x001B2744
	public unsafe float moveSpeed
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_moveSpeed);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_moveSpeed)) = value;
		}
	}

	// Token: 0x1700253F RID: 9535
	// (get) Token: 0x06006B84 RID: 27524 RVA: 0x001B4568 File Offset: 0x001B2768
	// (set) Token: 0x06006B85 RID: 27525 RVA: 0x001B4590 File Offset: 0x001B2790
	public unsafe float moveAngle
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_moveAngle);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_moveAngle)) = value;
		}
	}

	// Token: 0x17002540 RID: 9536
	// (get) Token: 0x06006B86 RID: 27526 RVA: 0x001B45B4 File Offset: 0x001B27B4
	// (set) Token: 0x06006B87 RID: 27527 RVA: 0x001B45DC File Offset: 0x001B27DC
	public unsafe float moveHorizontal
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_moveHorizontal);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_moveHorizontal)) = value;
		}
	}

	// Token: 0x17002541 RID: 9537
	// (get) Token: 0x06006B88 RID: 27528 RVA: 0x001B4600 File Offset: 0x001B2800
	// (set) Token: 0x06006B89 RID: 27529 RVA: 0x001B4628 File Offset: 0x001B2828
	public unsafe float moveVertical
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_moveVertical);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_moveVertical)) = value;
		}
	}

	// Token: 0x17002542 RID: 9538
	// (get) Token: 0x06006B8A RID: 27530 RVA: 0x001B464C File Offset: 0x001B284C
	// (set) Token: 0x06006B8B RID: 27531 RVA: 0x001B4674 File Offset: 0x001B2874
	public unsafe bool scriptMovement
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_scriptMovement);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_scriptMovement)) = value;
		}
	}

	// Token: 0x17002543 RID: 9539
	// (get) Token: 0x06006B8C RID: 27532 RVA: 0x001B4698 File Offset: 0x001B2898
	// (set) Token: 0x06006B8D RID: 27533 RVA: 0x001B46C0 File Offset: 0x001B28C0
	public unsafe bool isBattleState
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_isBattleState);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_isBattleState)) = value;
		}
	}

	// Token: 0x17002544 RID: 9540
	// (get) Token: 0x06006B8E RID: 27534 RVA: 0x001B46E4 File Offset: 0x001B28E4
	// (set) Token: 0x06006B8F RID: 27535 RVA: 0x001B470C File Offset: 0x001B290C
	public unsafe float battleTime
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_battleTime);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_battleTime)) = value;
		}
	}

	// Token: 0x17002545 RID: 9541
	// (get) Token: 0x06006B90 RID: 27536 RVA: 0x001B4730 File Offset: 0x001B2930
	// (set) Token: 0x06006B91 RID: 27537 RVA: 0x001B4758 File Offset: 0x001B2958
	public unsafe bool isIdleRandom
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_isIdleRandom);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_isIdleRandom)) = value;
		}
	}

	// Token: 0x17002546 RID: 9542
	// (get) Token: 0x06006B92 RID: 27538 RVA: 0x001B477C File Offset: 0x001B297C
	// (set) Token: 0x06006B93 RID: 27539 RVA: 0x001B47A4 File Offset: 0x001B29A4
	public unsafe float idleTime
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_idleTime);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_idleTime)) = value;
		}
	}

	// Token: 0x17002547 RID: 9543
	// (get) Token: 0x06006B94 RID: 27540 RVA: 0x001B47C8 File Offset: 0x001B29C8
	// (set) Token: 0x06006B95 RID: 27541 RVA: 0x001B47F0 File Offset: 0x001B29F0
	public unsafe float battleFace
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_battleFace);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_battleFace)) = value;
		}
	}

	// Token: 0x17002548 RID: 9544
	// (get) Token: 0x06006B96 RID: 27542 RVA: 0x001B4814 File Offset: 0x001B2A14
	// (set) Token: 0x06006B97 RID: 27543 RVA: 0x001B483C File Offset: 0x001B2A3C
	public unsafe float skyStayTime
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_skyStayTime);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_skyStayTime)) = value;
		}
	}

	// Token: 0x17002549 RID: 9545
	// (get) Token: 0x06006B98 RID: 27544 RVA: 0x001B4860 File Offset: 0x001B2A60
	// (set) Token: 0x06006B99 RID: 27545 RVA: 0x001B4888 File Offset: 0x001B2A88
	public unsafe float norFireWeight
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_norFireWeight);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_norFireWeight)) = value;
		}
	}

	// Token: 0x1700254A RID: 9546
	// (get) Token: 0x06006B9A RID: 27546 RVA: 0x001B48AC File Offset: 0x001B2AAC
	// (set) Token: 0x06006B9B RID: 27547 RVA: 0x001B48D4 File Offset: 0x001B2AD4
	public unsafe float norFireStayTime
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_norFireStayTime);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_norFireStayTime)) = value;
		}
	}

	// Token: 0x1700254B RID: 9547
	// (get) Token: 0x06006B9C RID: 27548 RVA: 0x001B48F8 File Offset: 0x001B2AF8
	// (set) Token: 0x06006B9D RID: 27549 RVA: 0x001B4920 File Offset: 0x001B2B20
	public unsafe float charge
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_charge);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_charge)) = value;
		}
	}

	// Token: 0x1700254C RID: 9548
	// (get) Token: 0x06006B9E RID: 27550 RVA: 0x001B4944 File Offset: 0x001B2B44
	// (set) Token: 0x06006B9F RID: 27551 RVA: 0x001B496C File Offset: 0x001B2B6C
	public unsafe float chargeValue
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_chargeValue);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_chargeValue)) = value;
		}
	}

	// Token: 0x1700254D RID: 9549
	// (get) Token: 0x06006BA0 RID: 27552 RVA: 0x001B4990 File Offset: 0x001B2B90
	// (set) Token: 0x06006BA1 RID: 27553 RVA: 0x001B49B8 File Offset: 0x001B2BB8
	public unsafe float useItem
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_useItem);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_useItem)) = value;
		}
	}

	// Token: 0x1700254E RID: 9550
	// (get) Token: 0x06006BA2 RID: 27554 RVA: 0x001B49DC File Offset: 0x001B2BDC
	// (set) Token: 0x06006BA3 RID: 27555 RVA: 0x001B4A04 File Offset: 0x001B2C04
	public unsafe float useItemValue
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_useItemValue);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_useItemValue)) = value;
		}
	}

	// Token: 0x1700254F RID: 9551
	// (get) Token: 0x06006BA4 RID: 27556 RVA: 0x001B4A28 File Offset: 0x001B2C28
	// (set) Token: 0x06006BA5 RID: 27557 RVA: 0x001B4A50 File Offset: 0x001B2C50
	public unsafe float holdShot
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_holdShot);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_holdShot)) = value;
		}
	}

	// Token: 0x17002550 RID: 9552
	// (get) Token: 0x06006BA6 RID: 27558 RVA: 0x001B4A74 File Offset: 0x001B2C74
	// (set) Token: 0x06006BA7 RID: 27559 RVA: 0x001B4A9C File Offset: 0x001B2C9C
	public unsafe float norFireAngle
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_norFireAngle);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_norFireAngle)) = value;
		}
	}

	// Token: 0x17002551 RID: 9553
	// (get) Token: 0x06006BA8 RID: 27560 RVA: 0x001B4AC0 File Offset: 0x001B2CC0
	// (set) Token: 0x06006BA9 RID: 27561 RVA: 0x001B4AE8 File Offset: 0x001B2CE8
	public unsafe float act01IdleHead
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_act01IdleHead);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_act01IdleHead)) = value;
		}
	}

	// Token: 0x17002552 RID: 9554
	// (get) Token: 0x06006BAA RID: 27562 RVA: 0x001B4B0C File Offset: 0x001B2D0C
	// (set) Token: 0x06006BAB RID: 27563 RVA: 0x001B4B34 File Offset: 0x001B2D34
	public unsafe float act01IdleHeadSet
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_act01IdleHeadSet);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_act01IdleHeadSet)) = value;
		}
	}

	// Token: 0x17002553 RID: 9555
	// (get) Token: 0x06006BAC RID: 27564 RVA: 0x001B4B58 File Offset: 0x001B2D58
	// (set) Token: 0x06006BAD RID: 27565 RVA: 0x001B4B80 File Offset: 0x001B2D80
	public unsafe bool windLayerEnable
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_windLayerEnable);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_windLayerEnable)) = value;
		}
	}

	// Token: 0x17002554 RID: 9556
	// (get) Token: 0x06006BAE RID: 27566 RVA: 0x001B4BA4 File Offset: 0x001B2DA4
	// (set) Token: 0x06006BAF RID: 27567 RVA: 0x001B4BCC File Offset: 0x001B2DCC
	public unsafe float windLayerWeight
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_windLayerWeight);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_windLayerWeight)) = value;
		}
	}

	// Token: 0x17002555 RID: 9557
	// (get) Token: 0x06006BB0 RID: 27568 RVA: 0x001B4BF0 File Offset: 0x001B2DF0
	// (set) Token: 0x06006BB1 RID: 27569 RVA: 0x001B4C18 File Offset: 0x001B2E18
	public unsafe float timeScale
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_timeScale);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_timeScale)) = value;
		}
	}

	// Token: 0x17002556 RID: 9558
	// (get) Token: 0x06006BB2 RID: 27570 RVA: 0x001B4C3C File Offset: 0x001B2E3C
	// (set) Token: 0x06006BB3 RID: 27571 RVA: 0x001B4C64 File Offset: 0x001B2E64
	public unsafe float battleTimeMax
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_battleTimeMax);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_battleTimeMax)) = value;
		}
	}

	// Token: 0x17002557 RID: 9559
	// (get) Token: 0x06006BB4 RID: 27572 RVA: 0x001B4C88 File Offset: 0x001B2E88
	// (set) Token: 0x06006BB5 RID: 27573 RVA: 0x001B4CB0 File Offset: 0x001B2EB0
	public unsafe float IdleTimeMax
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_IdleTimeMax);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_IdleTimeMax)) = value;
		}
	}

	// Token: 0x17002558 RID: 9560
	// (get) Token: 0x06006BB6 RID: 27574 RVA: 0x001B4CD4 File Offset: 0x001B2ED4
	// (set) Token: 0x06006BB7 RID: 27575 RVA: 0x001B4CFC File Offset: 0x001B2EFC
	public unsafe int switchIdleStateHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_switchIdleStateHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_switchIdleStateHash)) = value;
		}
	}

	// Token: 0x17002559 RID: 9561
	// (get) Token: 0x06006BB8 RID: 27576 RVA: 0x001B4D20 File Offset: 0x001B2F20
	// (set) Token: 0x06006BB9 RID: 27577 RVA: 0x001B4D48 File Offset: 0x001B2F48
	public unsafe int idleRandom01StateHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_idleRandom01StateHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_idleRandom01StateHash)) = value;
		}
	}

	// Token: 0x1700255A RID: 9562
	// (get) Token: 0x06006BBA RID: 27578 RVA: 0x001B4D6C File Offset: 0x001B2F6C
	// (set) Token: 0x06006BBB RID: 27579 RVA: 0x001B4D94 File Offset: 0x001B2F94
	public unsafe int idleRandom02StateHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_idleRandom02StateHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_idleRandom02StateHash)) = value;
		}
	}

	// Token: 0x1700255B RID: 9563
	// (get) Token: 0x06006BBC RID: 27580 RVA: 0x001B4DB8 File Offset: 0x001B2FB8
	// (set) Token: 0x06006BBD RID: 27581 RVA: 0x001B4DE0 File Offset: 0x001B2FE0
	public unsafe int brakingBattleStateHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_brakingBattleStateHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_brakingBattleStateHash)) = value;
		}
	}

	// Token: 0x1700255C RID: 9564
	// (get) Token: 0x06006BBE RID: 27582 RVA: 0x001B4E04 File Offset: 0x001B3004
	// (set) Token: 0x06006BBF RID: 27583 RVA: 0x001B4E2C File Offset: 0x001B302C
	public unsafe int brakingStateHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_brakingStateHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_brakingStateHash)) = value;
		}
	}

	// Token: 0x1700255D RID: 9565
	// (get) Token: 0x06006BC0 RID: 27584 RVA: 0x001B4E50 File Offset: 0x001B3050
	// (set) Token: 0x06006BC1 RID: 27585 RVA: 0x001B4E78 File Offset: 0x001B3078
	public unsafe int dodgeForwardStateHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_dodgeForwardStateHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_dodgeForwardStateHash)) = value;
		}
	}

	// Token: 0x1700255E RID: 9566
	// (get) Token: 0x06006BC2 RID: 27586 RVA: 0x001B4E9C File Offset: 0x001B309C
	// (set) Token: 0x06006BC3 RID: 27587 RVA: 0x001B4EC4 File Offset: 0x001B30C4
	public unsafe int dodgeBackwardStateHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_dodgeBackwardStateHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_dodgeBackwardStateHash)) = value;
		}
	}

	// Token: 0x1700255F RID: 9567
	// (get) Token: 0x06006BC4 RID: 27588 RVA: 0x001B4EE8 File Offset: 0x001B30E8
	// (set) Token: 0x06006BC5 RID: 27589 RVA: 0x001B4F10 File Offset: 0x001B3110
	public unsafe int heightLandBattleStateHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_heightLandBattleStateHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_heightLandBattleStateHash)) = value;
		}
	}

	// Token: 0x17002560 RID: 9568
	// (get) Token: 0x06006BC6 RID: 27590 RVA: 0x001B4F34 File Offset: 0x001B3134
	// (set) Token: 0x06006BC7 RID: 27591 RVA: 0x001B4F5C File Offset: 0x001B315C
	public unsafe int heightLandStateHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_heightLandStateHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_heightLandStateHash)) = value;
		}
	}

	// Token: 0x17002561 RID: 9569
	// (get) Token: 0x06006BC8 RID: 27592 RVA: 0x001B4F80 File Offset: 0x001B3180
	// (set) Token: 0x06006BC9 RID: 27593 RVA: 0x001B4FA8 File Offset: 0x001B31A8
	public unsafe int landBattleStateHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_landBattleStateHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_landBattleStateHash)) = value;
		}
	}

	// Token: 0x17002562 RID: 9570
	// (get) Token: 0x06006BCA RID: 27594 RVA: 0x001B4FCC File Offset: 0x001B31CC
	// (set) Token: 0x06006BCB RID: 27595 RVA: 0x001B4FF4 File Offset: 0x001B31F4
	public unsafe int landStateHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_landStateHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_landStateHash)) = value;
		}
	}

	// Token: 0x17002563 RID: 9571
	// (get) Token: 0x06006BCC RID: 27596 RVA: 0x001B5018 File Offset: 0x001B3218
	// (set) Token: 0x06006BCD RID: 27597 RVA: 0x001B5040 File Offset: 0x001B3240
	public unsafe int pickUpStateHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_pickUpStateHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_pickUpStateHash)) = value;
		}
	}

	// Token: 0x17002564 RID: 9572
	// (get) Token: 0x06006BCE RID: 27598 RVA: 0x001B5064 File Offset: 0x001B3264
	// (set) Token: 0x06006BCF RID: 27599 RVA: 0x001B508C File Offset: 0x001B328C
	public unsafe int discardItemStateHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_discardItemStateHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_discardItemStateHash)) = value;
		}
	}

	// Token: 0x17002565 RID: 9573
	// (get) Token: 0x06006BD0 RID: 27600 RVA: 0x001B50B0 File Offset: 0x001B32B0
	// (set) Token: 0x06006BD1 RID: 27601 RVA: 0x001B50D8 File Offset: 0x001B32D8
	public unsafe int lightUpStateHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_lightUpStateHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_lightUpStateHash)) = value;
		}
	}

	// Token: 0x17002566 RID: 9574
	// (get) Token: 0x06006BD2 RID: 27602 RVA: 0x001B50FC File Offset: 0x001B32FC
	// (set) Token: 0x06006BD3 RID: 27603 RVA: 0x001B5124 File Offset: 0x001B3324
	public unsafe int stage4LightBallStateHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_stage4LightBallStateHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_stage4LightBallStateHash)) = value;
		}
	}

	// Token: 0x17002567 RID: 9575
	// (get) Token: 0x06006BD4 RID: 27604 RVA: 0x001B5148 File Offset: 0x001B3348
	// (set) Token: 0x06006BD5 RID: 27605 RVA: 0x001B5170 File Offset: 0x001B3370
	public unsafe int switchOnStateHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_switchOnStateHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_switchOnStateHash)) = value;
		}
	}

	// Token: 0x17002568 RID: 9576
	// (get) Token: 0x06006BD6 RID: 27606 RVA: 0x001B5194 File Offset: 0x001B3394
	// (set) Token: 0x06006BD7 RID: 27607 RVA: 0x001B51BC File Offset: 0x001B33BC
	public unsafe int idleToPrayStateHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_idleToPrayStateHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_idleToPrayStateHash)) = value;
		}
	}

	// Token: 0x17002569 RID: 9577
	// (get) Token: 0x06006BD8 RID: 27608 RVA: 0x001B51E0 File Offset: 0x001B33E0
	// (set) Token: 0x06006BD9 RID: 27609 RVA: 0x001B5208 File Offset: 0x001B3408
	public unsafe int idleToPrayHeadUpStateHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_idleToPrayHeadUpStateHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_idleToPrayHeadUpStateHash)) = value;
		}
	}

	// Token: 0x1700256A RID: 9578
	// (get) Token: 0x06006BDA RID: 27610 RVA: 0x001B522C File Offset: 0x001B342C
	// (set) Token: 0x06006BDB RID: 27611 RVA: 0x001B5254 File Offset: 0x001B3454
	public unsafe int preyToIdleStateHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_preyToIdleStateHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_preyToIdleStateHash)) = value;
		}
	}

	// Token: 0x1700256B RID: 9579
	// (get) Token: 0x06006BDC RID: 27612 RVA: 0x001B5278 File Offset: 0x001B3478
	// (set) Token: 0x06006BDD RID: 27613 RVA: 0x001B52A0 File Offset: 0x001B34A0
	public unsafe int idleStateHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_idleStateHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_idleStateHash)) = value;
		}
	}

	// Token: 0x1700256C RID: 9580
	// (get) Token: 0x06006BDE RID: 27614 RVA: 0x001B52C4 File Offset: 0x001B34C4
	// (set) Token: 0x06006BDF RID: 27615 RVA: 0x001B52EC File Offset: 0x001B34EC
	public unsafe int aimShotStateHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_aimShotStateHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_aimShotStateHash)) = value;
		}
	}

	// Token: 0x1700256D RID: 9581
	// (get) Token: 0x06006BE0 RID: 27616 RVA: 0x001B5310 File Offset: 0x001B3510
	// (set) Token: 0x06006BE1 RID: 27617 RVA: 0x001B5338 File Offset: 0x001B3538
	public unsafe int aimNullShotStateHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_aimNullShotStateHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_aimNullShotStateHash)) = value;
		}
	}

	// Token: 0x1700256E RID: 9582
	// (get) Token: 0x06006BE2 RID: 27618 RVA: 0x001B535C File Offset: 0x001B355C
	// (set) Token: 0x06006BE3 RID: 27619 RVA: 0x001B5384 File Offset: 0x001B3584
	public unsafe int jumpBattleStateHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_jumpBattleStateHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_jumpBattleStateHash)) = value;
		}
	}

	// Token: 0x1700256F RID: 9583
	// (get) Token: 0x06006BE4 RID: 27620 RVA: 0x001B53A8 File Offset: 0x001B35A8
	// (set) Token: 0x06006BE5 RID: 27621 RVA: 0x001B53D0 File Offset: 0x001B35D0
	public unsafe int jumpStateHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_jumpStateHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_jumpStateHash)) = value;
		}
	}

	// Token: 0x17002570 RID: 9584
	// (get) Token: 0x06006BE6 RID: 27622 RVA: 0x001B53F4 File Offset: 0x001B35F4
	// (set) Token: 0x06006BE7 RID: 27623 RVA: 0x001B541C File Offset: 0x001B361C
	public unsafe int skyJumpBattleStateHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_skyJumpBattleStateHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_skyJumpBattleStateHash)) = value;
		}
	}

	// Token: 0x17002571 RID: 9585
	// (get) Token: 0x06006BE8 RID: 27624 RVA: 0x001B5440 File Offset: 0x001B3640
	// (set) Token: 0x06006BE9 RID: 27625 RVA: 0x001B5468 File Offset: 0x001B3668
	public unsafe int skyJumpStateHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_skyJumpStateHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_skyJumpStateHash)) = value;
		}
	}

	// Token: 0x17002572 RID: 9586
	// (get) Token: 0x06006BEA RID: 27626 RVA: 0x001B548C File Offset: 0x001B368C
	// (set) Token: 0x06006BEB RID: 27627 RVA: 0x001B54B4 File Offset: 0x001B36B4
	public unsafe int fallBattleStateHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_fallBattleStateHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_fallBattleStateHash)) = value;
		}
	}

	// Token: 0x17002573 RID: 9587
	// (get) Token: 0x06006BEC RID: 27628 RVA: 0x001B54D8 File Offset: 0x001B36D8
	// (set) Token: 0x06006BED RID: 27629 RVA: 0x001B5500 File Offset: 0x001B3700
	public unsafe int fallStateHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_fallStateHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_fallStateHash)) = value;
		}
	}

	// Token: 0x17002574 RID: 9588
	// (get) Token: 0x06006BEE RID: 27630 RVA: 0x001B5524 File Offset: 0x001B3724
	// (set) Token: 0x06006BEF RID: 27631 RVA: 0x001B554C File Offset: 0x001B374C
	public unsafe int speakNormalStateHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_speakNormalStateHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_speakNormalStateHash)) = value;
		}
	}

	// Token: 0x17002575 RID: 9589
	// (get) Token: 0x06006BF0 RID: 27632 RVA: 0x001B5570 File Offset: 0x001B3770
	// (set) Token: 0x06006BF1 RID: 27633 RVA: 0x001B5598 File Offset: 0x001B3798
	public unsafe int speakHappyStateHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_speakHappyStateHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_speakHappyStateHash)) = value;
		}
	}

	// Token: 0x17002576 RID: 9590
	// (get) Token: 0x06006BF2 RID: 27634 RVA: 0x001B55BC File Offset: 0x001B37BC
	// (set) Token: 0x06006BF3 RID: 27635 RVA: 0x001B55E4 File Offset: 0x001B37E4
	public unsafe int speakLoudlyStateHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_speakLoudlyStateHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_speakLoudlyStateHash)) = value;
		}
	}

	// Token: 0x17002577 RID: 9591
	// (get) Token: 0x06006BF4 RID: 27636 RVA: 0x001B5608 File Offset: 0x001B3808
	// (set) Token: 0x06006BF5 RID: 27637 RVA: 0x001B5630 File Offset: 0x001B3830
	public unsafe int moveSpeedHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_moveSpeedHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_moveSpeedHash)) = value;
		}
	}

	// Token: 0x17002578 RID: 9592
	// (get) Token: 0x06006BF6 RID: 27638 RVA: 0x001B5654 File Offset: 0x001B3854
	// (set) Token: 0x06006BF7 RID: 27639 RVA: 0x001B567C File Offset: 0x001B387C
	public unsafe int fearHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_fearHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_fearHash)) = value;
		}
	}

	// Token: 0x17002579 RID: 9593
	// (get) Token: 0x06006BF8 RID: 27640 RVA: 0x001B56A0 File Offset: 0x001B38A0
	// (set) Token: 0x06006BF9 RID: 27641 RVA: 0x001B56C8 File Offset: 0x001B38C8
	public unsafe int moveAngleHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_moveAngleHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_moveAngleHash)) = value;
		}
	}

	// Token: 0x1700257A RID: 9594
	// (get) Token: 0x06006BFA RID: 27642 RVA: 0x001B56EC File Offset: 0x001B38EC
	// (set) Token: 0x06006BFB RID: 27643 RVA: 0x001B5714 File Offset: 0x001B3914
	public unsafe int moveHorizontalHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_moveHorizontalHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_moveHorizontalHash)) = value;
		}
	}

	// Token: 0x1700257B RID: 9595
	// (get) Token: 0x06006BFC RID: 27644 RVA: 0x001B5738 File Offset: 0x001B3938
	// (set) Token: 0x06006BFD RID: 27645 RVA: 0x001B5760 File Offset: 0x001B3960
	public unsafe int moveVerticalHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_moveVerticalHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_moveVerticalHash)) = value;
		}
	}

	// Token: 0x1700257C RID: 9596
	// (get) Token: 0x06006BFE RID: 27646 RVA: 0x001B5784 File Offset: 0x001B3984
	// (set) Token: 0x06006BFF RID: 27647 RVA: 0x001B57AC File Offset: 0x001B39AC
	public unsafe int isSkyHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_isSkyHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_isSkyHash)) = value;
		}
	}

	// Token: 0x1700257D RID: 9597
	// (get) Token: 0x06006C00 RID: 27648 RVA: 0x001B57D0 File Offset: 0x001B39D0
	// (set) Token: 0x06006C01 RID: 27649 RVA: 0x001B57F8 File Offset: 0x001B39F8
	public unsafe int aimReadyHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_aimReadyHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_aimReadyHash)) = value;
		}
	}

	// Token: 0x1700257E RID: 9598
	// (get) Token: 0x06006C02 RID: 27650 RVA: 0x001B581C File Offset: 0x001B3A1C
	// (set) Token: 0x06006C03 RID: 27651 RVA: 0x001B5844 File Offset: 0x001B3A44
	public unsafe int aimHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_aimHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_aimHash)) = value;
		}
	}

	// Token: 0x1700257F RID: 9599
	// (get) Token: 0x06006C04 RID: 27652 RVA: 0x001B5868 File Offset: 0x001B3A68
	// (set) Token: 0x06006C05 RID: 27653 RVA: 0x001B5890 File Offset: 0x001B3A90
	public unsafe int isBattleHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_isBattleHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_isBattleHash)) = value;
		}
	}

	// Token: 0x17002580 RID: 9600
	// (get) Token: 0x06006C06 RID: 27654 RVA: 0x001B58B4 File Offset: 0x001B3AB4
	// (set) Token: 0x06006C07 RID: 27655 RVA: 0x001B58DC File Offset: 0x001B3ADC
	public unsafe int battleHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_battleHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_battleHash)) = value;
		}
	}

	// Token: 0x17002581 RID: 9601
	// (get) Token: 0x06006C08 RID: 27656 RVA: 0x001B5900 File Offset: 0x001B3B00
	// (set) Token: 0x06006C09 RID: 27657 RVA: 0x001B5928 File Offset: 0x001B3B28
	public unsafe int norFireAngleHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_norFireAngleHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_norFireAngleHash)) = value;
		}
	}

	// Token: 0x17002582 RID: 9602
	// (get) Token: 0x06006C0A RID: 27658 RVA: 0x001B594C File Offset: 0x001B3B4C
	// (set) Token: 0x06006C0B RID: 27659 RVA: 0x001B5974 File Offset: 0x001B3B74
	public unsafe int chargeHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_chargeHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_chargeHash)) = value;
		}
	}

	// Token: 0x17002583 RID: 9603
	// (get) Token: 0x06006C0C RID: 27660 RVA: 0x001B5998 File Offset: 0x001B3B98
	// (set) Token: 0x06006C0D RID: 27661 RVA: 0x001B59C0 File Offset: 0x001B3BC0
	public unsafe int useItemHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_useItemHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_useItemHash)) = value;
		}
	}

	// Token: 0x17002584 RID: 9604
	// (get) Token: 0x06006C0E RID: 27662 RVA: 0x001B59E4 File Offset: 0x001B3BE4
	// (set) Token: 0x06006C0F RID: 27663 RVA: 0x001B5A0C File Offset: 0x001B3C0C
	public unsafe int chargeMaxHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_chargeMaxHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_chargeMaxHash)) = value;
		}
	}

	// Token: 0x17002585 RID: 9605
	// (get) Token: 0x06006C10 RID: 27664 RVA: 0x001B5A30 File Offset: 0x001B3C30
	// (set) Token: 0x06006C11 RID: 27665 RVA: 0x001B5A58 File Offset: 0x001B3C58
	public unsafe int holdShotHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_holdShotHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_holdShotHash)) = value;
		}
	}

	// Token: 0x17002586 RID: 9606
	// (get) Token: 0x06006C12 RID: 27666 RVA: 0x001B5A7C File Offset: 0x001B3C7C
	// (set) Token: 0x06006C13 RID: 27667 RVA: 0x001B5AA4 File Offset: 0x001B3CA4
	public unsafe int act01IdleHeadHash
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_act01IdleHeadHash);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaAnimatorController.NativeFieldInfoPtr_act01IdleHeadHash)) = value;
		}
	}

	// Token: 0x0400474C RID: 18252
	private static readonly IntPtr NativeFieldInfoPtr_mainAnimator;

	// Token: 0x0400474D RID: 18253
	private static readonly IntPtr NativeFieldInfoPtr_faceAnimator;

	// Token: 0x0400474E RID: 18254
	private static readonly IntPtr NativeFieldInfoPtr_aimWeight;

	// Token: 0x0400474F RID: 18255
	private static readonly IntPtr NativeFieldInfoPtr_aimReadyWeight;

	// Token: 0x04004750 RID: 18256
	private static readonly IntPtr NativeFieldInfoPtr_fireLayerWeight;

	// Token: 0x04004751 RID: 18257
	private static readonly IntPtr NativeFieldInfoPtr_fireLayerStayTime;

	// Token: 0x04004752 RID: 18258
	private static readonly IntPtr NativeFieldInfoPtr_moveSpeed;

	// Token: 0x04004753 RID: 18259
	private static readonly IntPtr NativeFieldInfoPtr_moveAngle;

	// Token: 0x04004754 RID: 18260
	private static readonly IntPtr NativeFieldInfoPtr_moveHorizontal;

	// Token: 0x04004755 RID: 18261
	private static readonly IntPtr NativeFieldInfoPtr_moveVertical;

	// Token: 0x04004756 RID: 18262
	private static readonly IntPtr NativeFieldInfoPtr_scriptMovement;

	// Token: 0x04004757 RID: 18263
	private static readonly IntPtr NativeFieldInfoPtr_isBattleState;

	// Token: 0x04004758 RID: 18264
	private static readonly IntPtr NativeFieldInfoPtr_battleTime;

	// Token: 0x04004759 RID: 18265
	private static readonly IntPtr NativeFieldInfoPtr_isIdleRandom;

	// Token: 0x0400475A RID: 18266
	private static readonly IntPtr NativeFieldInfoPtr_idleTime;

	// Token: 0x0400475B RID: 18267
	private static readonly IntPtr NativeFieldInfoPtr_battleFace;

	// Token: 0x0400475C RID: 18268
	private static readonly IntPtr NativeFieldInfoPtr_skyStayTime;

	// Token: 0x0400475D RID: 18269
	private static readonly IntPtr NativeFieldInfoPtr_norFireWeight;

	// Token: 0x0400475E RID: 18270
	private static readonly IntPtr NativeFieldInfoPtr_norFireStayTime;

	// Token: 0x0400475F RID: 18271
	private static readonly IntPtr NativeFieldInfoPtr_charge;

	// Token: 0x04004760 RID: 18272
	private static readonly IntPtr NativeFieldInfoPtr_chargeValue;

	// Token: 0x04004761 RID: 18273
	private static readonly IntPtr NativeFieldInfoPtr_useItem;

	// Token: 0x04004762 RID: 18274
	private static readonly IntPtr NativeFieldInfoPtr_useItemValue;

	// Token: 0x04004763 RID: 18275
	private static readonly IntPtr NativeFieldInfoPtr_holdShot;

	// Token: 0x04004764 RID: 18276
	private static readonly IntPtr NativeFieldInfoPtr_norFireAngle;

	// Token: 0x04004765 RID: 18277
	private static readonly IntPtr NativeFieldInfoPtr_act01IdleHead;

	// Token: 0x04004766 RID: 18278
	private static readonly IntPtr NativeFieldInfoPtr_act01IdleHeadSet;

	// Token: 0x04004767 RID: 18279
	private static readonly IntPtr NativeFieldInfoPtr_windLayerEnable;

	// Token: 0x04004768 RID: 18280
	private static readonly IntPtr NativeFieldInfoPtr_windLayerWeight;

	// Token: 0x04004769 RID: 18281
	private static readonly IntPtr NativeFieldInfoPtr_timeScale;

	// Token: 0x0400476A RID: 18282
	private static readonly IntPtr NativeFieldInfoPtr_battleTimeMax;

	// Token: 0x0400476B RID: 18283
	private static readonly IntPtr NativeFieldInfoPtr_IdleTimeMax;

	// Token: 0x0400476C RID: 18284
	private static readonly IntPtr NativeFieldInfoPtr_switchIdleStateHash;

	// Token: 0x0400476D RID: 18285
	private static readonly IntPtr NativeFieldInfoPtr_idleRandom01StateHash;

	// Token: 0x0400476E RID: 18286
	private static readonly IntPtr NativeFieldInfoPtr_idleRandom02StateHash;

	// Token: 0x0400476F RID: 18287
	private static readonly IntPtr NativeFieldInfoPtr_brakingBattleStateHash;

	// Token: 0x04004770 RID: 18288
	private static readonly IntPtr NativeFieldInfoPtr_brakingStateHash;

	// Token: 0x04004771 RID: 18289
	private static readonly IntPtr NativeFieldInfoPtr_dodgeForwardStateHash;

	// Token: 0x04004772 RID: 18290
	private static readonly IntPtr NativeFieldInfoPtr_dodgeBackwardStateHash;

	// Token: 0x04004773 RID: 18291
	private static readonly IntPtr NativeFieldInfoPtr_heightLandBattleStateHash;

	// Token: 0x04004774 RID: 18292
	private static readonly IntPtr NativeFieldInfoPtr_heightLandStateHash;

	// Token: 0x04004775 RID: 18293
	private static readonly IntPtr NativeFieldInfoPtr_landBattleStateHash;

	// Token: 0x04004776 RID: 18294
	private static readonly IntPtr NativeFieldInfoPtr_landStateHash;

	// Token: 0x04004777 RID: 18295
	private static readonly IntPtr NativeFieldInfoPtr_pickUpStateHash;

	// Token: 0x04004778 RID: 18296
	private static readonly IntPtr NativeFieldInfoPtr_discardItemStateHash;

	// Token: 0x04004779 RID: 18297
	private static readonly IntPtr NativeFieldInfoPtr_lightUpStateHash;

	// Token: 0x0400477A RID: 18298
	private static readonly IntPtr NativeFieldInfoPtr_stage4LightBallStateHash;

	// Token: 0x0400477B RID: 18299
	private static readonly IntPtr NativeFieldInfoPtr_switchOnStateHash;

	// Token: 0x0400477C RID: 18300
	private static readonly IntPtr NativeFieldInfoPtr_idleToPrayStateHash;

	// Token: 0x0400477D RID: 18301
	private static readonly IntPtr NativeFieldInfoPtr_idleToPrayHeadUpStateHash;

	// Token: 0x0400477E RID: 18302
	private static readonly IntPtr NativeFieldInfoPtr_preyToIdleStateHash;

	// Token: 0x0400477F RID: 18303
	private static readonly IntPtr NativeFieldInfoPtr_idleStateHash;

	// Token: 0x04004780 RID: 18304
	private static readonly IntPtr NativeFieldInfoPtr_aimShotStateHash;

	// Token: 0x04004781 RID: 18305
	private static readonly IntPtr NativeFieldInfoPtr_aimNullShotStateHash;

	// Token: 0x04004782 RID: 18306
	private static readonly IntPtr NativeFieldInfoPtr_jumpBattleStateHash;

	// Token: 0x04004783 RID: 18307
	private static readonly IntPtr NativeFieldInfoPtr_jumpStateHash;

	// Token: 0x04004784 RID: 18308
	private static readonly IntPtr NativeFieldInfoPtr_skyJumpBattleStateHash;

	// Token: 0x04004785 RID: 18309
	private static readonly IntPtr NativeFieldInfoPtr_skyJumpStateHash;

	// Token: 0x04004786 RID: 18310
	private static readonly IntPtr NativeFieldInfoPtr_fallBattleStateHash;

	// Token: 0x04004787 RID: 18311
	private static readonly IntPtr NativeFieldInfoPtr_fallStateHash;

	// Token: 0x04004788 RID: 18312
	private static readonly IntPtr NativeFieldInfoPtr_speakNormalStateHash;

	// Token: 0x04004789 RID: 18313
	private static readonly IntPtr NativeFieldInfoPtr_speakHappyStateHash;

	// Token: 0x0400478A RID: 18314
	private static readonly IntPtr NativeFieldInfoPtr_speakLoudlyStateHash;

	// Token: 0x0400478B RID: 18315
	private static readonly IntPtr NativeFieldInfoPtr_moveSpeedHash;

	// Token: 0x0400478C RID: 18316
	private static readonly IntPtr NativeFieldInfoPtr_fearHash;

	// Token: 0x0400478D RID: 18317
	private static readonly IntPtr NativeFieldInfoPtr_moveAngleHash;

	// Token: 0x0400478E RID: 18318
	private static readonly IntPtr NativeFieldInfoPtr_moveHorizontalHash;

	// Token: 0x0400478F RID: 18319
	private static readonly IntPtr NativeFieldInfoPtr_moveVerticalHash;

	// Token: 0x04004790 RID: 18320
	private static readonly IntPtr NativeFieldInfoPtr_isSkyHash;

	// Token: 0x04004791 RID: 18321
	private static readonly IntPtr NativeFieldInfoPtr_aimReadyHash;

	// Token: 0x04004792 RID: 18322
	private static readonly IntPtr NativeFieldInfoPtr_aimHash;

	// Token: 0x04004793 RID: 18323
	private static readonly IntPtr NativeFieldInfoPtr_isBattleHash;

	// Token: 0x04004794 RID: 18324
	private static readonly IntPtr NativeFieldInfoPtr_battleHash;

	// Token: 0x04004795 RID: 18325
	private static readonly IntPtr NativeFieldInfoPtr_norFireAngleHash;

	// Token: 0x04004796 RID: 18326
	private static readonly IntPtr NativeFieldInfoPtr_chargeHash;

	// Token: 0x04004797 RID: 18327
	private static readonly IntPtr NativeFieldInfoPtr_useItemHash;

	// Token: 0x04004798 RID: 18328
	private static readonly IntPtr NativeFieldInfoPtr_chargeMaxHash;

	// Token: 0x04004799 RID: 18329
	private static readonly IntPtr NativeFieldInfoPtr_holdShotHash;

	// Token: 0x0400479A RID: 18330
	private static readonly IntPtr NativeFieldInfoPtr_act01IdleHeadHash;

	// Token: 0x0400479B RID: 18331
	private static readonly IntPtr NativeMethodInfoPtr_Init_Public_Void_Animator_Animator_0;

	// Token: 0x0400479C RID: 18332
	private static readonly IntPtr NativeMethodInfoPtr_Update_Public_Void_NobetaAnimatorData_0;

	// Token: 0x0400479D RID: 18333
	private static readonly IntPtr NativeMethodInfoPtr_PlayBraking_Public_Void_0;

	// Token: 0x0400479E RID: 18334
	private static readonly IntPtr NativeMethodInfoPtr_PlayDodgeForward_Public_Void_0;

	// Token: 0x0400479F RID: 18335
	private static readonly IntPtr NativeMethodInfoPtr_PlayDodgeBack_Public_Void_0;

	// Token: 0x040047A0 RID: 18336
	private static readonly IntPtr NativeMethodInfoPtr_PlayJump_Public_Void_Single_Single_0;

	// Token: 0x040047A1 RID: 18337
	private static readonly IntPtr NativeMethodInfoPtr_PlaySkyJump_Public_Void_Single_Single_0;

	// Token: 0x040047A2 RID: 18338
	private static readonly IntPtr NativeMethodInfoPtr_PlayFall_Public_Void_0;

	// Token: 0x040047A3 RID: 18339
	private static readonly IntPtr NativeMethodInfoPtr_PlayLand_Public_Void_Boolean_0;

	// Token: 0x040047A4 RID: 18340
	private static readonly IntPtr NativeMethodInfoPtr_PlayPickUp_Public_Void_0;

	// Token: 0x040047A5 RID: 18341
	private static readonly IntPtr NativeMethodInfoPtr_PlayDiscardItem_Public_Void_0;

	// Token: 0x040047A6 RID: 18342
	private static readonly IntPtr NativeMethodInfoPtr_PlayOnLight_Public_Void_0;

	// Token: 0x040047A7 RID: 18343
	private static readonly IntPtr NativeMethodInfoPtr_PlayLightBall_Public_Void_0;

	// Token: 0x040047A8 RID: 18344
	private static readonly IntPtr NativeMethodInfoPtr_PlaySwitchOn_Public_Void_0;

	// Token: 0x040047A9 RID: 18345
	private static readonly IntPtr NativeMethodInfoPtr_PlayPrayerStart_Public_Void_0;

	// Token: 0x040047AA RID: 18346
	private static readonly IntPtr NativeMethodInfoPtr_PlayPrayerEnd_Public_Void_0;

	// Token: 0x040047AB RID: 18347
	private static readonly IntPtr NativeMethodInfoPtr_PlayFire_Public_Void_0;

	// Token: 0x040047AC RID: 18348
	private static readonly IntPtr NativeMethodInfoPtr_PlayNullFire_Public_Void_0;

	// Token: 0x040047AD RID: 18349
	private static readonly IntPtr NativeMethodInfoPtr_PlayNormalFire_Public_Void_0;

	// Token: 0x040047AE RID: 18350
	private static readonly IntPtr NativeMethodInfoPtr_ResumeNoneBattleState_Private_Void_0;

	// Token: 0x040047AF RID: 18351
	private static readonly IntPtr NativeMethodInfoPtr_SetFireWeightZero_Public_Void_0;

	// Token: 0x040047B0 RID: 18352
	private static readonly IntPtr NativeMethodInfoPtr_SetMoveSpeed_Public_Void_Single_Boolean_0;

	// Token: 0x040047B1 RID: 18353
	private static readonly IntPtr NativeMethodInfoPtr_SetScriptMoveSpeed_Public_Void_Single_0;

	// Token: 0x040047B2 RID: 18354
	private static readonly IntPtr NativeMethodInfoPtr_SetBattleStatus_Public_Void_Boolean_0;

	// Token: 0x040047B3 RID: 18355
	private static readonly IntPtr NativeMethodInfoPtr_GetBattleStatus_Public_Boolean_0;

	// Token: 0x040047B4 RID: 18356
	private static readonly IntPtr NativeMethodInfoPtr_SetCharge_Public_Void_Boolean_0;

	// Token: 0x040047B5 RID: 18357
	private static readonly IntPtr NativeMethodInfoPtr_GetCharge_Public_Boolean_0;

	// Token: 0x040047B6 RID: 18358
	private static readonly IntPtr NativeMethodInfoPtr_SetUseItem_Public_Void_Boolean_0;

	// Token: 0x040047B7 RID: 18359
	private static readonly IntPtr NativeMethodInfoPtr_GetUseItem_Public_Boolean_0;

	// Token: 0x040047B8 RID: 18360
	private static readonly IntPtr NativeMethodInfoPtr_SetTimeScale_Public_Void_Single_0;

	// Token: 0x040047B9 RID: 18361
	private static readonly IntPtr NativeMethodInfoPtr_GetAnimator_Public_Animator_0;

	// Token: 0x040047BA RID: 18362
	private static readonly IntPtr NativeMethodInfoPtr_GetFaceAnimator_Public_Animator_0;

	// Token: 0x040047BB RID: 18363
	private static readonly IntPtr NativeMethodInfoPtr_SetAimWeight_Public_Void_Single_0;

	// Token: 0x040047BC RID: 18364
	private static readonly IntPtr NativeMethodInfoPtr_SetNorFireWeight_Public_Void_Single_0;

	// Token: 0x040047BD RID: 18365
	private static readonly IntPtr NativeMethodInfoPtr_SetHoldShot_Public_Void_Single_0;

	// Token: 0x040047BE RID: 18366
	private static readonly IntPtr NativeMethodInfoPtr_GetNorFireWeight_Public_Single_0;

	// Token: 0x040047BF RID: 18367
	private static readonly IntPtr NativeMethodInfoPtr_SetNorFireWeightZero_Public_Void_0;

	// Token: 0x040047C0 RID: 18368
	private static readonly IntPtr NativeMethodInfoPtr_SetFear_Public_Void_Boolean_0;

	// Token: 0x040047C1 RID: 18369
	private static readonly IntPtr NativeMethodInfoPtr_SetHeadHeight_Public_Void_Single_0;

	// Token: 0x040047C2 RID: 18370
	private static readonly IntPtr NativeMethodInfoPtr_SetSpeakLayerWeight_Public_Void_Boolean_Int32_0;

	// Token: 0x040047C3 RID: 18371
	private static readonly IntPtr NativeMethodInfoPtr_SetWindLayer_Public_Void_Boolean_0;

	// Token: 0x040047C4 RID: 18372
	private static readonly IntPtr NativeMethodInfoPtr_SetPreyAnimation_Public_Void_0;

	// Token: 0x040047C5 RID: 18373
	private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
}