NobetaSource/Interop/Assembly-CSharp/NobetaAnimatorController.cs

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

// Token: 0x0200036B RID: 875
[Serializable]
public class NobetaAnimatorController : Il2CppSystem.Object
{
	// Token: 0x060072D3 RID: 29395 RVA: 0x001D2634 File Offset: 0x001D0834
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 612533, RefRangeEnd = 612534, XrefRangeStart = 612531, XrefRangeEnd = 612533, 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: 0x060072D4 RID: 29396 RVA: 0x001D26A8 File Offset: 0x001D08A8
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 612598, RefRangeEnd = 612599, XrefRangeStart = 612534, XrefRangeEnd = 612598, 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: 0x060072D5 RID: 29397 RVA: 0x001D2704 File Offset: 0x001D0904
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 612601, RefRangeEnd = 612602, XrefRangeStart = 612599, XrefRangeEnd = 612601, 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: 0x060072D6 RID: 29398 RVA: 0x001D2748 File Offset: 0x001D0948
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 612603, RefRangeEnd = 612605, XrefRangeStart = 612602, XrefRangeEnd = 612603, 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: 0x060072D7 RID: 29399 RVA: 0x001D278C File Offset: 0x001D098C
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 612606, RefRangeEnd = 612608, XrefRangeStart = 612605, XrefRangeEnd = 612606, 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: 0x060072D8 RID: 29400 RVA: 0x001D27D0 File Offset: 0x001D09D0
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 612611, RefRangeEnd = 612613, XrefRangeStart = 612608, XrefRangeEnd = 612611, 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: 0x060072D9 RID: 29401 RVA: 0x001D2838 File Offset: 0x001D0A38
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 612616, RefRangeEnd = 612617, XrefRangeStart = 612613, XrefRangeEnd = 612616, 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: 0x060072DA RID: 29402 RVA: 0x001D28A0 File Offset: 0x001D0AA0
	[CallerCount(13)]
	[CachedScanResults(RefRangeStart = 612619, RefRangeEnd = 612632, XrefRangeStart = 612617, XrefRangeEnd = 612619, 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: 0x060072DB RID: 29403 RVA: 0x001D28E4 File Offset: 0x001D0AE4
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 612636, RefRangeEnd = 612637, XrefRangeStart = 612632, XrefRangeEnd = 612636, 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: 0x060072DC RID: 29404 RVA: 0x001D2938 File Offset: 0x001D0B38
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 612642, RefRangeEnd = 612643, XrefRangeStart = 612637, XrefRangeEnd = 612642, 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: 0x060072DD RID: 29405 RVA: 0x001D297C File Offset: 0x001D0B7C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 612648, RefRangeEnd = 612649, XrefRangeStart = 612643, XrefRangeEnd = 612648, 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: 0x060072DE RID: 29406 RVA: 0x001D29C0 File Offset: 0x001D0BC0
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 612655, RefRangeEnd = 612656, XrefRangeStart = 612649, XrefRangeEnd = 612655, 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: 0x060072DF RID: 29407 RVA: 0x001D2A04 File Offset: 0x001D0C04
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 612662, RefRangeEnd = 612663, XrefRangeStart = 612656, XrefRangeEnd = 612662, 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: 0x060072E0 RID: 29408 RVA: 0x001D2A48 File Offset: 0x001D0C48
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 612663, XrefRangeEnd = 612668, 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: 0x060072E1 RID: 29409 RVA: 0x001D2A8C File Offset: 0x001D0C8C
	[CallerCount(3)]
	[CachedScanResults(RefRangeStart = 612670, RefRangeEnd = 612673, XrefRangeStart = 612668, XrefRangeEnd = 612670, 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: 0x060072E2 RID: 29410 RVA: 0x001D2AD0 File Offset: 0x001D0CD0
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 612679, RefRangeEnd = 612683, XrefRangeStart = 612673, XrefRangeEnd = 612679, 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: 0x060072E3 RID: 29411 RVA: 0x001D2B14 File Offset: 0x001D0D14
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 612685, RefRangeEnd = 612686, XrefRangeStart = 612683, XrefRangeEnd = 612685, 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: 0x060072E4 RID: 29412 RVA: 0x001D2B58 File Offset: 0x001D0D58
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 612688, RefRangeEnd = 612689, XrefRangeStart = 612686, XrefRangeEnd = 612688, 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: 0x060072E5 RID: 29413 RVA: 0x001D2B9C File Offset: 0x001D0D9C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 612690, RefRangeEnd = 612691, XrefRangeStart = 612689, XrefRangeEnd = 612690, 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: 0x060072E6 RID: 29414 RVA: 0x001D2BE0 File Offset: 0x001D0DE0
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 612691, XrefRangeEnd = 612695, 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: 0x060072E7 RID: 29415 RVA: 0x001D2C24 File Offset: 0x001D0E24
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 612696, RefRangeEnd = 612698, XrefRangeStart = 612695, XrefRangeEnd = 612696, 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: 0x060072E8 RID: 29416 RVA: 0x001D2C68 File Offset: 0x001D0E68
	[CallerCount(25)]
	[CachedScanResults(RefRangeStart = 612703, RefRangeEnd = 612728, XrefRangeStart = 612698, XrefRangeEnd = 612703, 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: 0x060072E9 RID: 29417 RVA: 0x001D2CD0 File Offset: 0x001D0ED0
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 612731, RefRangeEnd = 612732, XrefRangeStart = 612728, XrefRangeEnd = 612731, 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: 0x060072EA RID: 29418 RVA: 0x001D2D24 File Offset: 0x001D0F24
	[CallerCount(20)]
	[CachedScanResults(RefRangeStart = 612735, RefRangeEnd = 612755, XrefRangeStart = 612732, XrefRangeEnd = 612735, 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: 0x060072EB RID: 29419 RVA: 0x001D2D78 File Offset: 0x001D0F78
	[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: 0x060072EC RID: 29420 RVA: 0x001D2DC8 File Offset: 0x001D0FC8
	[CallerCount(21)]
	[CachedScanResults(RefRangeStart = 612756, RefRangeEnd = 612777, XrefRangeStart = 612755, XrefRangeEnd = 612756, 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: 0x060072ED RID: 29421 RVA: 0x001D2E1C File Offset: 0x001D101C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 612777, RefRangeEnd = 612778, XrefRangeStart = 612777, XrefRangeEnd = 612777, 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: 0x060072EE RID: 29422 RVA: 0x001D2E6C File Offset: 0x001D106C
	[CallerCount(5)]
	[CachedScanResults(RefRangeStart = 612779, RefRangeEnd = 612784, XrefRangeStart = 612778, XrefRangeEnd = 612779, 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: 0x060072EF RID: 29423 RVA: 0x001D2EC0 File Offset: 0x001D10C0
	[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: 0x060072F0 RID: 29424 RVA: 0x001D2F10 File Offset: 0x001D1110
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 612787, RefRangeEnd = 612788, XrefRangeStart = 612784, XrefRangeEnd = 612787, 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: 0x060072F1 RID: 29425 RVA: 0x001D2F64 File Offset: 0x001D1164
	[CallerCount(9)]
	[CachedScanResults(RefRangeStart = 7538, RefRangeEnd = 7547, XrefRangeStart = 7538, XrefRangeEnd = 7547, 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: 0x060072F2 RID: 29426 RVA: 0x001D2FBC File Offset: 0x001D11BC
	[CallerCount(10)]
	[CachedScanResults(RefRangeStart = 7527, RefRangeEnd = 7537, XrefRangeStart = 7527, XrefRangeEnd = 7537, 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: 0x060072F3 RID: 29427 RVA: 0x001D3014 File Offset: 0x001D1214
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 225923, RefRangeEnd = 225924, XrefRangeStart = 225923, XrefRangeEnd = 225924, 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: 0x060072F4 RID: 29428 RVA: 0x001D3068 File Offset: 0x001D1268
	[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: 0x060072F5 RID: 29429 RVA: 0x001D30BC File Offset: 0x001D12BC
	[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: 0x060072F6 RID: 29430 RVA: 0x001D3110 File Offset: 0x001D1310
	[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: 0x060072F7 RID: 29431 RVA: 0x001D3160 File Offset: 0x001D1360
	[CallerCount(23)]
	[CachedScanResults(RefRangeStart = 612790, RefRangeEnd = 612813, XrefRangeStart = 612788, XrefRangeEnd = 612790, 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: 0x060072F8 RID: 29432 RVA: 0x001D31A4 File Offset: 0x001D13A4
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 612817, RefRangeEnd = 612818, XrefRangeStart = 612813, XrefRangeEnd = 612817, 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: 0x060072F9 RID: 29433 RVA: 0x001D31F8 File Offset: 0x001D13F8
	[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: 0x060072FA RID: 29434 RVA: 0x001D324C File Offset: 0x001D144C
	[CallerCount(5)]
	[CachedScanResults(RefRangeStart = 612821, RefRangeEnd = 612826, XrefRangeStart = 612818, XrefRangeEnd = 612821, 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: 0x060072FB RID: 29435 RVA: 0x001D32B4 File Offset: 0x001D14B4
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 612829, RefRangeEnd = 612831, XrefRangeStart = 612826, XrefRangeEnd = 612829, 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: 0x060072FC RID: 29436 RVA: 0x001D3308 File Offset: 0x001D1508
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 612836, RefRangeEnd = 612837, XrefRangeStart = 612831, XrefRangeEnd = 612836, 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: 0x060072FD RID: 29437 RVA: 0x001D334C File Offset: 0x001D154C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 612979, RefRangeEnd = 612980, XrefRangeStart = 612837, XrefRangeEnd = 612979, 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: 0x060072FE RID: 29438 RVA: 0x001D3398 File Offset: 0x001D1598
	// 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, 100671811);
		NobetaAnimatorController.NativeMethodInfoPtr_Update_Public_Void_NobetaAnimatorData_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671812);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayBraking_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671813);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayDodgeForward_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671814);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayDodgeBack_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671815);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayJump_Public_Void_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671816);
		NobetaAnimatorController.NativeMethodInfoPtr_PlaySkyJump_Public_Void_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671817);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayFall_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671818);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayLand_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671819);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayPickUp_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671820);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayDiscardItem_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671821);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayOnLight_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671822);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayLightBall_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671823);
		NobetaAnimatorController.NativeMethodInfoPtr_PlaySwitchOn_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671824);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayPrayerStart_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671825);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayPrayerEnd_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671826);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayFire_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671827);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayNullFire_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671828);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayNormalFire_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671829);
		NobetaAnimatorController.NativeMethodInfoPtr_ResumeNoneBattleState_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671830);
		NobetaAnimatorController.NativeMethodInfoPtr_SetFireWeightZero_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671831);
		NobetaAnimatorController.NativeMethodInfoPtr_SetMoveSpeed_Public_Void_Single_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671832);
		NobetaAnimatorController.NativeMethodInfoPtr_SetScriptMoveSpeed_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671833);
		NobetaAnimatorController.NativeMethodInfoPtr_SetBattleStatus_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671834);
		NobetaAnimatorController.NativeMethodInfoPtr_GetBattleStatus_Public_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671835);
		NobetaAnimatorController.NativeMethodInfoPtr_SetCharge_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671836);
		NobetaAnimatorController.NativeMethodInfoPtr_GetCharge_Public_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671837);
		NobetaAnimatorController.NativeMethodInfoPtr_SetUseItem_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671838);
		NobetaAnimatorController.NativeMethodInfoPtr_GetUseItem_Public_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671839);
		NobetaAnimatorController.NativeMethodInfoPtr_SetTimeScale_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671840);
		NobetaAnimatorController.NativeMethodInfoPtr_GetAnimator_Public_Animator_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671841);
		NobetaAnimatorController.NativeMethodInfoPtr_GetFaceAnimator_Public_Animator_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671842);
		NobetaAnimatorController.NativeMethodInfoPtr_SetAimWeight_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671843);
		NobetaAnimatorController.NativeMethodInfoPtr_SetNorFireWeight_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671844);
		NobetaAnimatorController.NativeMethodInfoPtr_SetHoldShot_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671845);
		NobetaAnimatorController.NativeMethodInfoPtr_GetNorFireWeight_Public_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671846);
		NobetaAnimatorController.NativeMethodInfoPtr_SetNorFireWeightZero_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671847);
		NobetaAnimatorController.NativeMethodInfoPtr_SetFear_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671848);
		NobetaAnimatorController.NativeMethodInfoPtr_SetHeadHeight_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671849);
		NobetaAnimatorController.NativeMethodInfoPtr_SetSpeakLayerWeight_Public_Void_Boolean_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671850);
		NobetaAnimatorController.NativeMethodInfoPtr_SetWindLayer_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671851);
		NobetaAnimatorController.NativeMethodInfoPtr_SetPreyAnimation_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671852);
		NobetaAnimatorController.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671853);
	}

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

	// Token: 0x1700279B RID: 10139
	// (get) Token: 0x06007300 RID: 29440 RVA: 0x001D3D50 File Offset: 0x001D1F50
	// (set) Token: 0x06007301 RID: 29441 RVA: 0x001D3D84 File Offset: 0x001D1F84
	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: 0x1700279C RID: 10140
	// (get) Token: 0x06007302 RID: 29442 RVA: 0x001D3DAC File Offset: 0x001D1FAC
	// (set) Token: 0x06007303 RID: 29443 RVA: 0x001D3DE0 File Offset: 0x001D1FE0
	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: 0x1700279D RID: 10141
	// (get) Token: 0x06007304 RID: 29444 RVA: 0x001D3E08 File Offset: 0x001D2008
	// (set) Token: 0x06007305 RID: 29445 RVA: 0x001D3E30 File Offset: 0x001D2030
	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: 0x1700279E RID: 10142
	// (get) Token: 0x06007306 RID: 29446 RVA: 0x001D3E54 File Offset: 0x001D2054
	// (set) Token: 0x06007307 RID: 29447 RVA: 0x001D3E7C File Offset: 0x001D207C
	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: 0x1700279F RID: 10143
	// (get) Token: 0x06007308 RID: 29448 RVA: 0x001D3EA0 File Offset: 0x001D20A0
	// (set) Token: 0x06007309 RID: 29449 RVA: 0x001D3EC8 File Offset: 0x001D20C8
	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: 0x170027A0 RID: 10144
	// (get) Token: 0x0600730A RID: 29450 RVA: 0x001D3EEC File Offset: 0x001D20EC
	// (set) Token: 0x0600730B RID: 29451 RVA: 0x001D3F14 File Offset: 0x001D2114
	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: 0x170027A1 RID: 10145
	// (get) Token: 0x0600730C RID: 29452 RVA: 0x001D3F38 File Offset: 0x001D2138
	// (set) Token: 0x0600730D RID: 29453 RVA: 0x001D3F60 File Offset: 0x001D2160
	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: 0x170027A2 RID: 10146
	// (get) Token: 0x0600730E RID: 29454 RVA: 0x001D3F84 File Offset: 0x001D2184
	// (set) Token: 0x0600730F RID: 29455 RVA: 0x001D3FAC File Offset: 0x001D21AC
	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: 0x170027A3 RID: 10147
	// (get) Token: 0x06007310 RID: 29456 RVA: 0x001D3FD0 File Offset: 0x001D21D0
	// (set) Token: 0x06007311 RID: 29457 RVA: 0x001D3FF8 File Offset: 0x001D21F8
	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: 0x170027A4 RID: 10148
	// (get) Token: 0x06007312 RID: 29458 RVA: 0x001D401C File Offset: 0x001D221C
	// (set) Token: 0x06007313 RID: 29459 RVA: 0x001D4044 File Offset: 0x001D2244
	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: 0x170027A5 RID: 10149
	// (get) Token: 0x06007314 RID: 29460 RVA: 0x001D4068 File Offset: 0x001D2268
	// (set) Token: 0x06007315 RID: 29461 RVA: 0x001D4090 File Offset: 0x001D2290
	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: 0x170027A6 RID: 10150
	// (get) Token: 0x06007316 RID: 29462 RVA: 0x001D40B4 File Offset: 0x001D22B4
	// (set) Token: 0x06007317 RID: 29463 RVA: 0x001D40DC File Offset: 0x001D22DC
	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: 0x170027A7 RID: 10151
	// (get) Token: 0x06007318 RID: 29464 RVA: 0x001D4100 File Offset: 0x001D2300
	// (set) Token: 0x06007319 RID: 29465 RVA: 0x001D4128 File Offset: 0x001D2328
	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: 0x170027A8 RID: 10152
	// (get) Token: 0x0600731A RID: 29466 RVA: 0x001D414C File Offset: 0x001D234C
	// (set) Token: 0x0600731B RID: 29467 RVA: 0x001D4174 File Offset: 0x001D2374
	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: 0x170027A9 RID: 10153
	// (get) Token: 0x0600731C RID: 29468 RVA: 0x001D4198 File Offset: 0x001D2398
	// (set) Token: 0x0600731D RID: 29469 RVA: 0x001D41C0 File Offset: 0x001D23C0
	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: 0x170027AA RID: 10154
	// (get) Token: 0x0600731E RID: 29470 RVA: 0x001D41E4 File Offset: 0x001D23E4
	// (set) Token: 0x0600731F RID: 29471 RVA: 0x001D420C File Offset: 0x001D240C
	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: 0x170027AB RID: 10155
	// (get) Token: 0x06007320 RID: 29472 RVA: 0x001D4230 File Offset: 0x001D2430
	// (set) Token: 0x06007321 RID: 29473 RVA: 0x001D4258 File Offset: 0x001D2458
	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: 0x170027AC RID: 10156
	// (get) Token: 0x06007322 RID: 29474 RVA: 0x001D427C File Offset: 0x001D247C
	// (set) Token: 0x06007323 RID: 29475 RVA: 0x001D42A4 File Offset: 0x001D24A4
	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: 0x170027AD RID: 10157
	// (get) Token: 0x06007324 RID: 29476 RVA: 0x001D42C8 File Offset: 0x001D24C8
	// (set) Token: 0x06007325 RID: 29477 RVA: 0x001D42F0 File Offset: 0x001D24F0
	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: 0x170027AE RID: 10158
	// (get) Token: 0x06007326 RID: 29478 RVA: 0x001D4314 File Offset: 0x001D2514
	// (set) Token: 0x06007327 RID: 29479 RVA: 0x001D433C File Offset: 0x001D253C
	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: 0x170027AF RID: 10159
	// (get) Token: 0x06007328 RID: 29480 RVA: 0x001D4360 File Offset: 0x001D2560
	// (set) Token: 0x06007329 RID: 29481 RVA: 0x001D4388 File Offset: 0x001D2588
	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: 0x170027B0 RID: 10160
	// (get) Token: 0x0600732A RID: 29482 RVA: 0x001D43AC File Offset: 0x001D25AC
	// (set) Token: 0x0600732B RID: 29483 RVA: 0x001D43D4 File Offset: 0x001D25D4
	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: 0x170027B1 RID: 10161
	// (get) Token: 0x0600732C RID: 29484 RVA: 0x001D43F8 File Offset: 0x001D25F8
	// (set) Token: 0x0600732D RID: 29485 RVA: 0x001D4420 File Offset: 0x001D2620
	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: 0x170027B2 RID: 10162
	// (get) Token: 0x0600732E RID: 29486 RVA: 0x001D4444 File Offset: 0x001D2644
	// (set) Token: 0x0600732F RID: 29487 RVA: 0x001D446C File Offset: 0x001D266C
	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: 0x170027B3 RID: 10163
	// (get) Token: 0x06007330 RID: 29488 RVA: 0x001D4490 File Offset: 0x001D2690
	// (set) Token: 0x06007331 RID: 29489 RVA: 0x001D44B8 File Offset: 0x001D26B8
	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: 0x170027B4 RID: 10164
	// (get) Token: 0x06007332 RID: 29490 RVA: 0x001D44DC File Offset: 0x001D26DC
	// (set) Token: 0x06007333 RID: 29491 RVA: 0x001D4504 File Offset: 0x001D2704
	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: 0x170027B5 RID: 10165
	// (get) Token: 0x06007334 RID: 29492 RVA: 0x001D4528 File Offset: 0x001D2728
	// (set) Token: 0x06007335 RID: 29493 RVA: 0x001D4550 File Offset: 0x001D2750
	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: 0x170027B6 RID: 10166
	// (get) Token: 0x06007336 RID: 29494 RVA: 0x001D4574 File Offset: 0x001D2774
	// (set) Token: 0x06007337 RID: 29495 RVA: 0x001D459C File Offset: 0x001D279C
	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: 0x170027B7 RID: 10167
	// (get) Token: 0x06007338 RID: 29496 RVA: 0x001D45C0 File Offset: 0x001D27C0
	// (set) Token: 0x06007339 RID: 29497 RVA: 0x001D45E8 File Offset: 0x001D27E8
	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: 0x170027B8 RID: 10168
	// (get) Token: 0x0600733A RID: 29498 RVA: 0x001D460C File Offset: 0x001D280C
	// (set) Token: 0x0600733B RID: 29499 RVA: 0x001D4634 File Offset: 0x001D2834
	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: 0x170027B9 RID: 10169
	// (get) Token: 0x0600733C RID: 29500 RVA: 0x001D4658 File Offset: 0x001D2858
	// (set) Token: 0x0600733D RID: 29501 RVA: 0x001D4680 File Offset: 0x001D2880
	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: 0x170027BA RID: 10170
	// (get) Token: 0x0600733E RID: 29502 RVA: 0x001D46A4 File Offset: 0x001D28A4
	// (set) Token: 0x0600733F RID: 29503 RVA: 0x001D46CC File Offset: 0x001D28CC
	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: 0x170027BB RID: 10171
	// (get) Token: 0x06007340 RID: 29504 RVA: 0x001D46F0 File Offset: 0x001D28F0
	// (set) Token: 0x06007341 RID: 29505 RVA: 0x001D4718 File Offset: 0x001D2918
	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: 0x170027BC RID: 10172
	// (get) Token: 0x06007342 RID: 29506 RVA: 0x001D473C File Offset: 0x001D293C
	// (set) Token: 0x06007343 RID: 29507 RVA: 0x001D4764 File Offset: 0x001D2964
	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: 0x170027BD RID: 10173
	// (get) Token: 0x06007344 RID: 29508 RVA: 0x001D4788 File Offset: 0x001D2988
	// (set) Token: 0x06007345 RID: 29509 RVA: 0x001D47B0 File Offset: 0x001D29B0
	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: 0x170027BE RID: 10174
	// (get) Token: 0x06007346 RID: 29510 RVA: 0x001D47D4 File Offset: 0x001D29D4
	// (set) Token: 0x06007347 RID: 29511 RVA: 0x001D47FC File Offset: 0x001D29FC
	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: 0x170027BF RID: 10175
	// (get) Token: 0x06007348 RID: 29512 RVA: 0x001D4820 File Offset: 0x001D2A20
	// (set) Token: 0x06007349 RID: 29513 RVA: 0x001D4848 File Offset: 0x001D2A48
	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: 0x170027C0 RID: 10176
	// (get) Token: 0x0600734A RID: 29514 RVA: 0x001D486C File Offset: 0x001D2A6C
	// (set) Token: 0x0600734B RID: 29515 RVA: 0x001D4894 File Offset: 0x001D2A94
	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: 0x170027C1 RID: 10177
	// (get) Token: 0x0600734C RID: 29516 RVA: 0x001D48B8 File Offset: 0x001D2AB8
	// (set) Token: 0x0600734D RID: 29517 RVA: 0x001D48E0 File Offset: 0x001D2AE0
	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: 0x170027C2 RID: 10178
	// (get) Token: 0x0600734E RID: 29518 RVA: 0x001D4904 File Offset: 0x001D2B04
	// (set) Token: 0x0600734F RID: 29519 RVA: 0x001D492C File Offset: 0x001D2B2C
	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: 0x170027C3 RID: 10179
	// (get) Token: 0x06007350 RID: 29520 RVA: 0x001D4950 File Offset: 0x001D2B50
	// (set) Token: 0x06007351 RID: 29521 RVA: 0x001D4978 File Offset: 0x001D2B78
	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: 0x170027C4 RID: 10180
	// (get) Token: 0x06007352 RID: 29522 RVA: 0x001D499C File Offset: 0x001D2B9C
	// (set) Token: 0x06007353 RID: 29523 RVA: 0x001D49C4 File Offset: 0x001D2BC4
	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: 0x170027C5 RID: 10181
	// (get) Token: 0x06007354 RID: 29524 RVA: 0x001D49E8 File Offset: 0x001D2BE8
	// (set) Token: 0x06007355 RID: 29525 RVA: 0x001D4A10 File Offset: 0x001D2C10
	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: 0x170027C6 RID: 10182
	// (get) Token: 0x06007356 RID: 29526 RVA: 0x001D4A34 File Offset: 0x001D2C34
	// (set) Token: 0x06007357 RID: 29527 RVA: 0x001D4A5C File Offset: 0x001D2C5C
	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: 0x170027C7 RID: 10183
	// (get) Token: 0x06007358 RID: 29528 RVA: 0x001D4A80 File Offset: 0x001D2C80
	// (set) Token: 0x06007359 RID: 29529 RVA: 0x001D4AA8 File Offset: 0x001D2CA8
	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: 0x170027C8 RID: 10184
	// (get) Token: 0x0600735A RID: 29530 RVA: 0x001D4ACC File Offset: 0x001D2CCC
	// (set) Token: 0x0600735B RID: 29531 RVA: 0x001D4AF4 File Offset: 0x001D2CF4
	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: 0x170027C9 RID: 10185
	// (get) Token: 0x0600735C RID: 29532 RVA: 0x001D4B18 File Offset: 0x001D2D18
	// (set) Token: 0x0600735D RID: 29533 RVA: 0x001D4B40 File Offset: 0x001D2D40
	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: 0x170027CA RID: 10186
	// (get) Token: 0x0600735E RID: 29534 RVA: 0x001D4B64 File Offset: 0x001D2D64
	// (set) Token: 0x0600735F RID: 29535 RVA: 0x001D4B8C File Offset: 0x001D2D8C
	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: 0x170027CB RID: 10187
	// (get) Token: 0x06007360 RID: 29536 RVA: 0x001D4BB0 File Offset: 0x001D2DB0
	// (set) Token: 0x06007361 RID: 29537 RVA: 0x001D4BD8 File Offset: 0x001D2DD8
	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: 0x170027CC RID: 10188
	// (get) Token: 0x06007362 RID: 29538 RVA: 0x001D4BFC File Offset: 0x001D2DFC
	// (set) Token: 0x06007363 RID: 29539 RVA: 0x001D4C24 File Offset: 0x001D2E24
	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: 0x170027CD RID: 10189
	// (get) Token: 0x06007364 RID: 29540 RVA: 0x001D4C48 File Offset: 0x001D2E48
	// (set) Token: 0x06007365 RID: 29541 RVA: 0x001D4C70 File Offset: 0x001D2E70
	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: 0x170027CE RID: 10190
	// (get) Token: 0x06007366 RID: 29542 RVA: 0x001D4C94 File Offset: 0x001D2E94
	// (set) Token: 0x06007367 RID: 29543 RVA: 0x001D4CBC File Offset: 0x001D2EBC
	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: 0x170027CF RID: 10191
	// (get) Token: 0x06007368 RID: 29544 RVA: 0x001D4CE0 File Offset: 0x001D2EE0
	// (set) Token: 0x06007369 RID: 29545 RVA: 0x001D4D08 File Offset: 0x001D2F08
	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: 0x170027D0 RID: 10192
	// (get) Token: 0x0600736A RID: 29546 RVA: 0x001D4D2C File Offset: 0x001D2F2C
	// (set) Token: 0x0600736B RID: 29547 RVA: 0x001D4D54 File Offset: 0x001D2F54
	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: 0x170027D1 RID: 10193
	// (get) Token: 0x0600736C RID: 29548 RVA: 0x001D4D78 File Offset: 0x001D2F78
	// (set) Token: 0x0600736D RID: 29549 RVA: 0x001D4DA0 File Offset: 0x001D2FA0
	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: 0x170027D2 RID: 10194
	// (get) Token: 0x0600736E RID: 29550 RVA: 0x001D4DC4 File Offset: 0x001D2FC4
	// (set) Token: 0x0600736F RID: 29551 RVA: 0x001D4DEC File Offset: 0x001D2FEC
	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: 0x170027D3 RID: 10195
	// (get) Token: 0x06007370 RID: 29552 RVA: 0x001D4E10 File Offset: 0x001D3010
	// (set) Token: 0x06007371 RID: 29553 RVA: 0x001D4E38 File Offset: 0x001D3038
	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: 0x170027D4 RID: 10196
	// (get) Token: 0x06007372 RID: 29554 RVA: 0x001D4E5C File Offset: 0x001D305C
	// (set) Token: 0x06007373 RID: 29555 RVA: 0x001D4E84 File Offset: 0x001D3084
	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: 0x170027D5 RID: 10197
	// (get) Token: 0x06007374 RID: 29556 RVA: 0x001D4EA8 File Offset: 0x001D30A8
	// (set) Token: 0x06007375 RID: 29557 RVA: 0x001D4ED0 File Offset: 0x001D30D0
	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: 0x170027D6 RID: 10198
	// (get) Token: 0x06007376 RID: 29558 RVA: 0x001D4EF4 File Offset: 0x001D30F4
	// (set) Token: 0x06007377 RID: 29559 RVA: 0x001D4F1C File Offset: 0x001D311C
	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: 0x170027D7 RID: 10199
	// (get) Token: 0x06007378 RID: 29560 RVA: 0x001D4F40 File Offset: 0x001D3140
	// (set) Token: 0x06007379 RID: 29561 RVA: 0x001D4F68 File Offset: 0x001D3168
	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: 0x170027D8 RID: 10200
	// (get) Token: 0x0600737A RID: 29562 RVA: 0x001D4F8C File Offset: 0x001D318C
	// (set) Token: 0x0600737B RID: 29563 RVA: 0x001D4FB4 File Offset: 0x001D31B4
	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: 0x170027D9 RID: 10201
	// (get) Token: 0x0600737C RID: 29564 RVA: 0x001D4FD8 File Offset: 0x001D31D8
	// (set) Token: 0x0600737D RID: 29565 RVA: 0x001D5000 File Offset: 0x001D3200
	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: 0x170027DA RID: 10202
	// (get) Token: 0x0600737E RID: 29566 RVA: 0x001D5024 File Offset: 0x001D3224
	// (set) Token: 0x0600737F RID: 29567 RVA: 0x001D504C File Offset: 0x001D324C
	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: 0x170027DB RID: 10203
	// (get) Token: 0x06007380 RID: 29568 RVA: 0x001D5070 File Offset: 0x001D3270
	// (set) Token: 0x06007381 RID: 29569 RVA: 0x001D5098 File Offset: 0x001D3298
	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: 0x170027DC RID: 10204
	// (get) Token: 0x06007382 RID: 29570 RVA: 0x001D50BC File Offset: 0x001D32BC
	// (set) Token: 0x06007383 RID: 29571 RVA: 0x001D50E4 File Offset: 0x001D32E4
	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: 0x170027DD RID: 10205
	// (get) Token: 0x06007384 RID: 29572 RVA: 0x001D5108 File Offset: 0x001D3308
	// (set) Token: 0x06007385 RID: 29573 RVA: 0x001D5130 File Offset: 0x001D3330
	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: 0x170027DE RID: 10206
	// (get) Token: 0x06007386 RID: 29574 RVA: 0x001D5154 File Offset: 0x001D3354
	// (set) Token: 0x06007387 RID: 29575 RVA: 0x001D517C File Offset: 0x001D337C
	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: 0x170027DF RID: 10207
	// (get) Token: 0x06007388 RID: 29576 RVA: 0x001D51A0 File Offset: 0x001D33A0
	// (set) Token: 0x06007389 RID: 29577 RVA: 0x001D51C8 File Offset: 0x001D33C8
	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: 0x170027E0 RID: 10208
	// (get) Token: 0x0600738A RID: 29578 RVA: 0x001D51EC File Offset: 0x001D33EC
	// (set) Token: 0x0600738B RID: 29579 RVA: 0x001D5214 File Offset: 0x001D3414
	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: 0x170027E1 RID: 10209
	// (get) Token: 0x0600738C RID: 29580 RVA: 0x001D5238 File Offset: 0x001D3438
	// (set) Token: 0x0600738D RID: 29581 RVA: 0x001D5260 File Offset: 0x001D3460
	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: 0x170027E2 RID: 10210
	// (get) Token: 0x0600738E RID: 29582 RVA: 0x001D5284 File Offset: 0x001D3484
	// (set) Token: 0x0600738F RID: 29583 RVA: 0x001D52AC File Offset: 0x001D34AC
	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: 0x170027E3 RID: 10211
	// (get) Token: 0x06007390 RID: 29584 RVA: 0x001D52D0 File Offset: 0x001D34D0
	// (set) Token: 0x06007391 RID: 29585 RVA: 0x001D52F8 File Offset: 0x001D34F8
	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: 0x170027E4 RID: 10212
	// (get) Token: 0x06007392 RID: 29586 RVA: 0x001D531C File Offset: 0x001D351C
	// (set) Token: 0x06007393 RID: 29587 RVA: 0x001D5344 File Offset: 0x001D3544
	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: 0x170027E5 RID: 10213
	// (get) Token: 0x06007394 RID: 29588 RVA: 0x001D5368 File Offset: 0x001D3568
	// (set) Token: 0x06007395 RID: 29589 RVA: 0x001D5390 File Offset: 0x001D3590
	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: 0x170027E6 RID: 10214
	// (get) Token: 0x06007396 RID: 29590 RVA: 0x001D53B4 File Offset: 0x001D35B4
	// (set) Token: 0x06007397 RID: 29591 RVA: 0x001D53DC File Offset: 0x001D35DC
	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: 0x170027E7 RID: 10215
	// (get) Token: 0x06007398 RID: 29592 RVA: 0x001D5400 File Offset: 0x001D3600
	// (set) Token: 0x06007399 RID: 29593 RVA: 0x001D5428 File Offset: 0x001D3628
	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: 0x170027E8 RID: 10216
	// (get) Token: 0x0600739A RID: 29594 RVA: 0x001D544C File Offset: 0x001D364C
	// (set) Token: 0x0600739B RID: 29595 RVA: 0x001D5474 File Offset: 0x001D3674
	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: 0x170027E9 RID: 10217
	// (get) Token: 0x0600739C RID: 29596 RVA: 0x001D5498 File Offset: 0x001D3698
	// (set) Token: 0x0600739D RID: 29597 RVA: 0x001D54C0 File Offset: 0x001D36C0
	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: 0x04004C70 RID: 19568
	private static readonly IntPtr NativeFieldInfoPtr_mainAnimator;

	// Token: 0x04004C71 RID: 19569
	private static readonly IntPtr NativeFieldInfoPtr_faceAnimator;

	// Token: 0x04004C72 RID: 19570
	private static readonly IntPtr NativeFieldInfoPtr_aimWeight;

	// Token: 0x04004C73 RID: 19571
	private static readonly IntPtr NativeFieldInfoPtr_aimReadyWeight;

	// Token: 0x04004C74 RID: 19572
	private static readonly IntPtr NativeFieldInfoPtr_fireLayerWeight;

	// Token: 0x04004C75 RID: 19573
	private static readonly IntPtr NativeFieldInfoPtr_fireLayerStayTime;

	// Token: 0x04004C76 RID: 19574
	private static readonly IntPtr NativeFieldInfoPtr_moveSpeed;

	// Token: 0x04004C77 RID: 19575
	private static readonly IntPtr NativeFieldInfoPtr_moveAngle;

	// Token: 0x04004C78 RID: 19576
	private static readonly IntPtr NativeFieldInfoPtr_moveHorizontal;

	// Token: 0x04004C79 RID: 19577
	private static readonly IntPtr NativeFieldInfoPtr_moveVertical;

	// Token: 0x04004C7A RID: 19578
	private static readonly IntPtr NativeFieldInfoPtr_scriptMovement;

	// Token: 0x04004C7B RID: 19579
	private static readonly IntPtr NativeFieldInfoPtr_isBattleState;

	// Token: 0x04004C7C RID: 19580
	private static readonly IntPtr NativeFieldInfoPtr_battleTime;

	// Token: 0x04004C7D RID: 19581
	private static readonly IntPtr NativeFieldInfoPtr_isIdleRandom;

	// Token: 0x04004C7E RID: 19582
	private static readonly IntPtr NativeFieldInfoPtr_idleTime;

	// Token: 0x04004C7F RID: 19583
	private static readonly IntPtr NativeFieldInfoPtr_battleFace;

	// Token: 0x04004C80 RID: 19584
	private static readonly IntPtr NativeFieldInfoPtr_skyStayTime;

	// Token: 0x04004C81 RID: 19585
	private static readonly IntPtr NativeFieldInfoPtr_norFireWeight;

	// Token: 0x04004C82 RID: 19586
	private static readonly IntPtr NativeFieldInfoPtr_norFireStayTime;

	// Token: 0x04004C83 RID: 19587
	private static readonly IntPtr NativeFieldInfoPtr_charge;

	// Token: 0x04004C84 RID: 19588
	private static readonly IntPtr NativeFieldInfoPtr_chargeValue;

	// Token: 0x04004C85 RID: 19589
	private static readonly IntPtr NativeFieldInfoPtr_useItem;

	// Token: 0x04004C86 RID: 19590
	private static readonly IntPtr NativeFieldInfoPtr_useItemValue;

	// Token: 0x04004C87 RID: 19591
	private static readonly IntPtr NativeFieldInfoPtr_holdShot;

	// Token: 0x04004C88 RID: 19592
	private static readonly IntPtr NativeFieldInfoPtr_norFireAngle;

	// Token: 0x04004C89 RID: 19593
	private static readonly IntPtr NativeFieldInfoPtr_act01IdleHead;

	// Token: 0x04004C8A RID: 19594
	private static readonly IntPtr NativeFieldInfoPtr_act01IdleHeadSet;

	// Token: 0x04004C8B RID: 19595
	private static readonly IntPtr NativeFieldInfoPtr_windLayerEnable;

	// Token: 0x04004C8C RID: 19596
	private static readonly IntPtr NativeFieldInfoPtr_windLayerWeight;

	// Token: 0x04004C8D RID: 19597
	private static readonly IntPtr NativeFieldInfoPtr_timeScale;

	// Token: 0x04004C8E RID: 19598
	private static readonly IntPtr NativeFieldInfoPtr_battleTimeMax;

	// Token: 0x04004C8F RID: 19599
	private static readonly IntPtr NativeFieldInfoPtr_IdleTimeMax;

	// Token: 0x04004C90 RID: 19600
	private static readonly IntPtr NativeFieldInfoPtr_switchIdleStateHash;

	// Token: 0x04004C91 RID: 19601
	private static readonly IntPtr NativeFieldInfoPtr_idleRandom01StateHash;

	// Token: 0x04004C92 RID: 19602
	private static readonly IntPtr NativeFieldInfoPtr_idleRandom02StateHash;

	// Token: 0x04004C93 RID: 19603
	private static readonly IntPtr NativeFieldInfoPtr_brakingBattleStateHash;

	// Token: 0x04004C94 RID: 19604
	private static readonly IntPtr NativeFieldInfoPtr_brakingStateHash;

	// Token: 0x04004C95 RID: 19605
	private static readonly IntPtr NativeFieldInfoPtr_dodgeForwardStateHash;

	// Token: 0x04004C96 RID: 19606
	private static readonly IntPtr NativeFieldInfoPtr_dodgeBackwardStateHash;

	// Token: 0x04004C97 RID: 19607
	private static readonly IntPtr NativeFieldInfoPtr_heightLandBattleStateHash;

	// Token: 0x04004C98 RID: 19608
	private static readonly IntPtr NativeFieldInfoPtr_heightLandStateHash;

	// Token: 0x04004C99 RID: 19609
	private static readonly IntPtr NativeFieldInfoPtr_landBattleStateHash;

	// Token: 0x04004C9A RID: 19610
	private static readonly IntPtr NativeFieldInfoPtr_landStateHash;

	// Token: 0x04004C9B RID: 19611
	private static readonly IntPtr NativeFieldInfoPtr_pickUpStateHash;

	// Token: 0x04004C9C RID: 19612
	private static readonly IntPtr NativeFieldInfoPtr_discardItemStateHash;

	// Token: 0x04004C9D RID: 19613
	private static readonly IntPtr NativeFieldInfoPtr_lightUpStateHash;

	// Token: 0x04004C9E RID: 19614
	private static readonly IntPtr NativeFieldInfoPtr_stage4LightBallStateHash;

	// Token: 0x04004C9F RID: 19615
	private static readonly IntPtr NativeFieldInfoPtr_switchOnStateHash;

	// Token: 0x04004CA0 RID: 19616
	private static readonly IntPtr NativeFieldInfoPtr_idleToPrayStateHash;

	// Token: 0x04004CA1 RID: 19617
	private static readonly IntPtr NativeFieldInfoPtr_idleToPrayHeadUpStateHash;

	// Token: 0x04004CA2 RID: 19618
	private static readonly IntPtr NativeFieldInfoPtr_preyToIdleStateHash;

	// Token: 0x04004CA3 RID: 19619
	private static readonly IntPtr NativeFieldInfoPtr_idleStateHash;

	// Token: 0x04004CA4 RID: 19620
	private static readonly IntPtr NativeFieldInfoPtr_aimShotStateHash;

	// Token: 0x04004CA5 RID: 19621
	private static readonly IntPtr NativeFieldInfoPtr_aimNullShotStateHash;

	// Token: 0x04004CA6 RID: 19622
	private static readonly IntPtr NativeFieldInfoPtr_jumpBattleStateHash;

	// Token: 0x04004CA7 RID: 19623
	private static readonly IntPtr NativeFieldInfoPtr_jumpStateHash;

	// Token: 0x04004CA8 RID: 19624
	private static readonly IntPtr NativeFieldInfoPtr_skyJumpBattleStateHash;

	// Token: 0x04004CA9 RID: 19625
	private static readonly IntPtr NativeFieldInfoPtr_skyJumpStateHash;

	// Token: 0x04004CAA RID: 19626
	private static readonly IntPtr NativeFieldInfoPtr_fallBattleStateHash;

	// Token: 0x04004CAB RID: 19627
	private static readonly IntPtr NativeFieldInfoPtr_fallStateHash;

	// Token: 0x04004CAC RID: 19628
	private static readonly IntPtr NativeFieldInfoPtr_speakNormalStateHash;

	// Token: 0x04004CAD RID: 19629
	private static readonly IntPtr NativeFieldInfoPtr_speakHappyStateHash;

	// Token: 0x04004CAE RID: 19630
	private static readonly IntPtr NativeFieldInfoPtr_speakLoudlyStateHash;

	// Token: 0x04004CAF RID: 19631
	private static readonly IntPtr NativeFieldInfoPtr_moveSpeedHash;

	// Token: 0x04004CB0 RID: 19632
	private static readonly IntPtr NativeFieldInfoPtr_fearHash;

	// Token: 0x04004CB1 RID: 19633
	private static readonly IntPtr NativeFieldInfoPtr_moveAngleHash;

	// Token: 0x04004CB2 RID: 19634
	private static readonly IntPtr NativeFieldInfoPtr_moveHorizontalHash;

	// Token: 0x04004CB3 RID: 19635
	private static readonly IntPtr NativeFieldInfoPtr_moveVerticalHash;

	// Token: 0x04004CB4 RID: 19636
	private static readonly IntPtr NativeFieldInfoPtr_isSkyHash;

	// Token: 0x04004CB5 RID: 19637
	private static readonly IntPtr NativeFieldInfoPtr_aimReadyHash;

	// Token: 0x04004CB6 RID: 19638
	private static readonly IntPtr NativeFieldInfoPtr_aimHash;

	// Token: 0x04004CB7 RID: 19639
	private static readonly IntPtr NativeFieldInfoPtr_isBattleHash;

	// Token: 0x04004CB8 RID: 19640
	private static readonly IntPtr NativeFieldInfoPtr_battleHash;

	// Token: 0x04004CB9 RID: 19641
	private static readonly IntPtr NativeFieldInfoPtr_norFireAngleHash;

	// Token: 0x04004CBA RID: 19642
	private static readonly IntPtr NativeFieldInfoPtr_chargeHash;

	// Token: 0x04004CBB RID: 19643
	private static readonly IntPtr NativeFieldInfoPtr_useItemHash;

	// Token: 0x04004CBC RID: 19644
	private static readonly IntPtr NativeFieldInfoPtr_chargeMaxHash;

	// Token: 0x04004CBD RID: 19645
	private static readonly IntPtr NativeFieldInfoPtr_holdShotHash;

	// Token: 0x04004CBE RID: 19646
	private static readonly IntPtr NativeFieldInfoPtr_act01IdleHeadHash;

	// Token: 0x04004CBF RID: 19647
	private static readonly IntPtr NativeMethodInfoPtr_Init_Public_Void_Animator_Animator_0;

	// Token: 0x04004CC0 RID: 19648
	private static readonly IntPtr NativeMethodInfoPtr_Update_Public_Void_NobetaAnimatorData_0;

	// Token: 0x04004CC1 RID: 19649
	private static readonly IntPtr NativeMethodInfoPtr_PlayBraking_Public_Void_0;

	// Token: 0x04004CC2 RID: 19650
	private static readonly IntPtr NativeMethodInfoPtr_PlayDodgeForward_Public_Void_0;

	// Token: 0x04004CC3 RID: 19651
	private static readonly IntPtr NativeMethodInfoPtr_PlayDodgeBack_Public_Void_0;

	// Token: 0x04004CC4 RID: 19652
	private static readonly IntPtr NativeMethodInfoPtr_PlayJump_Public_Void_Single_Single_0;

	// Token: 0x04004CC5 RID: 19653
	private static readonly IntPtr NativeMethodInfoPtr_PlaySkyJump_Public_Void_Single_Single_0;

	// Token: 0x04004CC6 RID: 19654
	private static readonly IntPtr NativeMethodInfoPtr_PlayFall_Public_Void_0;

	// Token: 0x04004CC7 RID: 19655
	private static readonly IntPtr NativeMethodInfoPtr_PlayLand_Public_Void_Boolean_0;

	// Token: 0x04004CC8 RID: 19656
	private static readonly IntPtr NativeMethodInfoPtr_PlayPickUp_Public_Void_0;

	// Token: 0x04004CC9 RID: 19657
	private static readonly IntPtr NativeMethodInfoPtr_PlayDiscardItem_Public_Void_0;

	// Token: 0x04004CCA RID: 19658
	private static readonly IntPtr NativeMethodInfoPtr_PlayOnLight_Public_Void_0;

	// Token: 0x04004CCB RID: 19659
	private static readonly IntPtr NativeMethodInfoPtr_PlayLightBall_Public_Void_0;

	// Token: 0x04004CCC RID: 19660
	private static readonly IntPtr NativeMethodInfoPtr_PlaySwitchOn_Public_Void_0;

	// Token: 0x04004CCD RID: 19661
	private static readonly IntPtr NativeMethodInfoPtr_PlayPrayerStart_Public_Void_0;

	// Token: 0x04004CCE RID: 19662
	private static readonly IntPtr NativeMethodInfoPtr_PlayPrayerEnd_Public_Void_0;

	// Token: 0x04004CCF RID: 19663
	private static readonly IntPtr NativeMethodInfoPtr_PlayFire_Public_Void_0;

	// Token: 0x04004CD0 RID: 19664
	private static readonly IntPtr NativeMethodInfoPtr_PlayNullFire_Public_Void_0;

	// Token: 0x04004CD1 RID: 19665
	private static readonly IntPtr NativeMethodInfoPtr_PlayNormalFire_Public_Void_0;

	// Token: 0x04004CD2 RID: 19666
	private static readonly IntPtr NativeMethodInfoPtr_ResumeNoneBattleState_Private_Void_0;

	// Token: 0x04004CD3 RID: 19667
	private static readonly IntPtr NativeMethodInfoPtr_SetFireWeightZero_Public_Void_0;

	// Token: 0x04004CD4 RID: 19668
	private static readonly IntPtr NativeMethodInfoPtr_SetMoveSpeed_Public_Void_Single_Boolean_0;

	// Token: 0x04004CD5 RID: 19669
	private static readonly IntPtr NativeMethodInfoPtr_SetScriptMoveSpeed_Public_Void_Single_0;

	// Token: 0x04004CD6 RID: 19670
	private static readonly IntPtr NativeMethodInfoPtr_SetBattleStatus_Public_Void_Boolean_0;

	// Token: 0x04004CD7 RID: 19671
	private static readonly IntPtr NativeMethodInfoPtr_GetBattleStatus_Public_Boolean_0;

	// Token: 0x04004CD8 RID: 19672
	private static readonly IntPtr NativeMethodInfoPtr_SetCharge_Public_Void_Boolean_0;

	// Token: 0x04004CD9 RID: 19673
	private static readonly IntPtr NativeMethodInfoPtr_GetCharge_Public_Boolean_0;

	// Token: 0x04004CDA RID: 19674
	private static readonly IntPtr NativeMethodInfoPtr_SetUseItem_Public_Void_Boolean_0;

	// Token: 0x04004CDB RID: 19675
	private static readonly IntPtr NativeMethodInfoPtr_GetUseItem_Public_Boolean_0;

	// Token: 0x04004CDC RID: 19676
	private static readonly IntPtr NativeMethodInfoPtr_SetTimeScale_Public_Void_Single_0;

	// Token: 0x04004CDD RID: 19677
	private static readonly IntPtr NativeMethodInfoPtr_GetAnimator_Public_Animator_0;

	// Token: 0x04004CDE RID: 19678
	private static readonly IntPtr NativeMethodInfoPtr_GetFaceAnimator_Public_Animator_0;

	// Token: 0x04004CDF RID: 19679
	private static readonly IntPtr NativeMethodInfoPtr_SetAimWeight_Public_Void_Single_0;

	// Token: 0x04004CE0 RID: 19680
	private static readonly IntPtr NativeMethodInfoPtr_SetNorFireWeight_Public_Void_Single_0;

	// Token: 0x04004CE1 RID: 19681
	private static readonly IntPtr NativeMethodInfoPtr_SetHoldShot_Public_Void_Single_0;

	// Token: 0x04004CE2 RID: 19682
	private static readonly IntPtr NativeMethodInfoPtr_GetNorFireWeight_Public_Single_0;

	// Token: 0x04004CE3 RID: 19683
	private static readonly IntPtr NativeMethodInfoPtr_SetNorFireWeightZero_Public_Void_0;

	// Token: 0x04004CE4 RID: 19684
	private static readonly IntPtr NativeMethodInfoPtr_SetFear_Public_Void_Boolean_0;

	// Token: 0x04004CE5 RID: 19685
	private static readonly IntPtr NativeMethodInfoPtr_SetHeadHeight_Public_Void_Single_0;

	// Token: 0x04004CE6 RID: 19686
	private static readonly IntPtr NativeMethodInfoPtr_SetSpeakLayerWeight_Public_Void_Boolean_Int32_0;

	// Token: 0x04004CE7 RID: 19687
	private static readonly IntPtr NativeMethodInfoPtr_SetWindLayer_Public_Void_Boolean_0;

	// Token: 0x04004CE8 RID: 19688
	private static readonly IntPtr NativeMethodInfoPtr_SetPreyAnimation_Public_Void_0;

	// Token: 0x04004CE9 RID: 19689
	private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
}