NobetaSource/Interop/Assembly-CSharp/NobetaAnimatorController.cs

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

// Token: 0x02000316 RID: 790
[Serializable]
public class NobetaAnimatorController : Il2CppSystem.Object
{
	// Token: 0x06006AB8 RID: 27320 RVA: 0x001B08F4 File Offset: 0x001AEAF4
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 580728, RefRangeEnd = 580729, XrefRangeStart = 580726, XrefRangeEnd = 580728, 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: 0x06006AB9 RID: 27321 RVA: 0x001B0968 File Offset: 0x001AEB68
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 580793, RefRangeEnd = 580794, XrefRangeStart = 580729, XrefRangeEnd = 580793, 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: 0x06006ABA RID: 27322 RVA: 0x001B09C4 File Offset: 0x001AEBC4
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 580796, RefRangeEnd = 580797, XrefRangeStart = 580794, XrefRangeEnd = 580796, 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: 0x06006ABB RID: 27323 RVA: 0x001B0A08 File Offset: 0x001AEC08
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 580798, RefRangeEnd = 580800, XrefRangeStart = 580797, XrefRangeEnd = 580798, 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: 0x06006ABC RID: 27324 RVA: 0x001B0A4C File Offset: 0x001AEC4C
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 580801, RefRangeEnd = 580803, XrefRangeStart = 580800, XrefRangeEnd = 580801, 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: 0x06006ABD RID: 27325 RVA: 0x001B0A90 File Offset: 0x001AEC90
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 580806, RefRangeEnd = 580808, XrefRangeStart = 580803, XrefRangeEnd = 580806, 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: 0x06006ABE RID: 27326 RVA: 0x001B0AF8 File Offset: 0x001AECF8
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 580811, RefRangeEnd = 580812, XrefRangeStart = 580808, XrefRangeEnd = 580811, 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: 0x06006ABF RID: 27327 RVA: 0x001B0B60 File Offset: 0x001AED60
	[CallerCount(13)]
	[CachedScanResults(RefRangeStart = 580814, RefRangeEnd = 580827, XrefRangeStart = 580812, XrefRangeEnd = 580814, 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: 0x06006AC0 RID: 27328 RVA: 0x001B0BA4 File Offset: 0x001AEDA4
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 580831, RefRangeEnd = 580832, XrefRangeStart = 580827, XrefRangeEnd = 580831, 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: 0x06006AC1 RID: 27329 RVA: 0x001B0BF8 File Offset: 0x001AEDF8
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 580837, RefRangeEnd = 580838, XrefRangeStart = 580832, XrefRangeEnd = 580837, 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: 0x06006AC2 RID: 27330 RVA: 0x001B0C3C File Offset: 0x001AEE3C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 580843, RefRangeEnd = 580844, XrefRangeStart = 580838, XrefRangeEnd = 580843, 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: 0x06006AC3 RID: 27331 RVA: 0x001B0C80 File Offset: 0x001AEE80
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 580850, RefRangeEnd = 580851, XrefRangeStart = 580844, XrefRangeEnd = 580850, 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: 0x06006AC4 RID: 27332 RVA: 0x001B0CC4 File Offset: 0x001AEEC4
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 580857, RefRangeEnd = 580858, XrefRangeStart = 580851, XrefRangeEnd = 580857, 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: 0x06006AC5 RID: 27333 RVA: 0x001B0D08 File Offset: 0x001AEF08
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 580858, XrefRangeEnd = 580863, 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: 0x06006AC6 RID: 27334 RVA: 0x001B0D4C File Offset: 0x001AEF4C
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 580865, RefRangeEnd = 580867, XrefRangeStart = 580863, XrefRangeEnd = 580865, 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: 0x06006AC7 RID: 27335 RVA: 0x001B0D90 File Offset: 0x001AEF90
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 580873, RefRangeEnd = 580875, XrefRangeStart = 580867, XrefRangeEnd = 580873, 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: 0x06006AC8 RID: 27336 RVA: 0x001B0DD4 File Offset: 0x001AEFD4
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 580877, RefRangeEnd = 580878, XrefRangeStart = 580875, XrefRangeEnd = 580877, 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: 0x06006AC9 RID: 27337 RVA: 0x001B0E18 File Offset: 0x001AF018
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 580880, RefRangeEnd = 580881, XrefRangeStart = 580878, XrefRangeEnd = 580880, 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: 0x06006ACA RID: 27338 RVA: 0x001B0E5C File Offset: 0x001AF05C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 580882, RefRangeEnd = 580883, XrefRangeStart = 580881, XrefRangeEnd = 580882, 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: 0x06006ACB RID: 27339 RVA: 0x001B0EA0 File Offset: 0x001AF0A0
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 580883, XrefRangeEnd = 580887, 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: 0x06006ACC RID: 27340 RVA: 0x001B0EE4 File Offset: 0x001AF0E4
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 580888, RefRangeEnd = 580890, XrefRangeStart = 580887, XrefRangeEnd = 580888, 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: 0x06006ACD RID: 27341 RVA: 0x001B0F28 File Offset: 0x001AF128
	[CallerCount(23)]
	[CachedScanResults(RefRangeStart = 580895, RefRangeEnd = 580918, XrefRangeStart = 580890, XrefRangeEnd = 580895, 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: 0x06006ACE RID: 27342 RVA: 0x001B0F90 File Offset: 0x001AF190
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 580921, RefRangeEnd = 580922, XrefRangeStart = 580918, XrefRangeEnd = 580921, 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: 0x06006ACF RID: 27343 RVA: 0x001B0FE4 File Offset: 0x001AF1E4
	[CallerCount(19)]
	[CachedScanResults(RefRangeStart = 580925, RefRangeEnd = 580944, XrefRangeStart = 580922, XrefRangeEnd = 580925, 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: 0x06006AD0 RID: 27344 RVA: 0x001B1038 File Offset: 0x001AF238
	[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: 0x06006AD1 RID: 27345 RVA: 0x001B1088 File Offset: 0x001AF288
	[CallerCount(21)]
	[CachedScanResults(RefRangeStart = 580945, RefRangeEnd = 580966, XrefRangeStart = 580944, XrefRangeEnd = 580945, 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: 0x06006AD2 RID: 27346 RVA: 0x001B10DC File Offset: 0x001AF2DC
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 580966, RefRangeEnd = 580967, XrefRangeStart = 580966, XrefRangeEnd = 580966, 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: 0x06006AD3 RID: 27347 RVA: 0x001B112C File Offset: 0x001AF32C
	[CallerCount(5)]
	[CachedScanResults(RefRangeStart = 580968, RefRangeEnd = 580973, XrefRangeStart = 580967, XrefRangeEnd = 580968, 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: 0x06006AD4 RID: 27348 RVA: 0x001B1180 File Offset: 0x001AF380
	[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: 0x06006AD5 RID: 27349 RVA: 0x001B11D0 File Offset: 0x001AF3D0
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 580976, RefRangeEnd = 580977, XrefRangeStart = 580973, XrefRangeEnd = 580976, 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: 0x06006AD6 RID: 27350 RVA: 0x001B1224 File Offset: 0x001AF424
	[CallerCount(9)]
	[CachedScanResults(RefRangeStart = 7244, RefRangeEnd = 7253, XrefRangeStart = 7244, XrefRangeEnd = 7253, 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: 0x06006AD7 RID: 27351 RVA: 0x001B127C File Offset: 0x001AF47C
	[CallerCount(10)]
	[CachedScanResults(RefRangeStart = 7233, RefRangeEnd = 7243, XrefRangeStart = 7233, XrefRangeEnd = 7243, 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: 0x06006AD8 RID: 27352 RVA: 0x001B12D4 File Offset: 0x001AF4D4
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 218203, RefRangeEnd = 218204, XrefRangeStart = 218203, XrefRangeEnd = 218204, 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: 0x06006AD9 RID: 27353 RVA: 0x001B1328 File Offset: 0x001AF528
	[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: 0x06006ADA RID: 27354 RVA: 0x001B137C File Offset: 0x001AF57C
	[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: 0x06006ADB RID: 27355 RVA: 0x001B13D0 File Offset: 0x001AF5D0
	[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: 0x06006ADC RID: 27356 RVA: 0x001B1420 File Offset: 0x001AF620
	[CallerCount(22)]
	[CachedScanResults(RefRangeStart = 580979, RefRangeEnd = 581001, XrefRangeStart = 580977, XrefRangeEnd = 580979, 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: 0x06006ADD RID: 27357 RVA: 0x001B1464 File Offset: 0x001AF664
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 581005, RefRangeEnd = 581006, XrefRangeStart = 581001, XrefRangeEnd = 581005, 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: 0x06006ADE RID: 27358 RVA: 0x001B14B8 File Offset: 0x001AF6B8
	[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: 0x06006ADF RID: 27359 RVA: 0x001B150C File Offset: 0x001AF70C
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 581009, RefRangeEnd = 581013, XrefRangeStart = 581006, XrefRangeEnd = 581009, 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: 0x06006AE0 RID: 27360 RVA: 0x001B1574 File Offset: 0x001AF774
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 581016, RefRangeEnd = 581018, XrefRangeStart = 581013, XrefRangeEnd = 581016, 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: 0x06006AE1 RID: 27361 RVA: 0x001B15C8 File Offset: 0x001AF7C8
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 581023, RefRangeEnd = 581024, XrefRangeStart = 581018, XrefRangeEnd = 581023, 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: 0x06006AE2 RID: 27362 RVA: 0x001B160C File Offset: 0x001AF80C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 581166, RefRangeEnd = 581167, XrefRangeStart = 581024, XrefRangeEnd = 581166, 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: 0x06006AE3 RID: 27363 RVA: 0x001B1658 File Offset: 0x001AF858
	// 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, 100671124);
		NobetaAnimatorController.NativeMethodInfoPtr_Update_Public_Void_NobetaAnimatorData_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671125);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayBraking_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671126);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayDodgeForward_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671127);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayDodgeBack_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671128);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayJump_Public_Void_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671129);
		NobetaAnimatorController.NativeMethodInfoPtr_PlaySkyJump_Public_Void_Single_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671130);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayFall_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671131);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayLand_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671132);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayPickUp_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671133);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayDiscardItem_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671134);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayOnLight_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671135);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayLightBall_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671136);
		NobetaAnimatorController.NativeMethodInfoPtr_PlaySwitchOn_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671137);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayPrayerStart_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671138);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayPrayerEnd_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671139);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayFire_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671140);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayNullFire_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671141);
		NobetaAnimatorController.NativeMethodInfoPtr_PlayNormalFire_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671142);
		NobetaAnimatorController.NativeMethodInfoPtr_ResumeNoneBattleState_Private_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671143);
		NobetaAnimatorController.NativeMethodInfoPtr_SetFireWeightZero_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671144);
		NobetaAnimatorController.NativeMethodInfoPtr_SetMoveSpeed_Public_Void_Single_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671145);
		NobetaAnimatorController.NativeMethodInfoPtr_SetScriptMoveSpeed_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671146);
		NobetaAnimatorController.NativeMethodInfoPtr_SetBattleStatus_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671147);
		NobetaAnimatorController.NativeMethodInfoPtr_GetBattleStatus_Public_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671148);
		NobetaAnimatorController.NativeMethodInfoPtr_SetCharge_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671149);
		NobetaAnimatorController.NativeMethodInfoPtr_GetCharge_Public_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671150);
		NobetaAnimatorController.NativeMethodInfoPtr_SetUseItem_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671151);
		NobetaAnimatorController.NativeMethodInfoPtr_GetUseItem_Public_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671152);
		NobetaAnimatorController.NativeMethodInfoPtr_SetTimeScale_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671153);
		NobetaAnimatorController.NativeMethodInfoPtr_GetAnimator_Public_Animator_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671154);
		NobetaAnimatorController.NativeMethodInfoPtr_GetFaceAnimator_Public_Animator_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671155);
		NobetaAnimatorController.NativeMethodInfoPtr_SetAimWeight_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671156);
		NobetaAnimatorController.NativeMethodInfoPtr_SetNorFireWeight_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671157);
		NobetaAnimatorController.NativeMethodInfoPtr_SetHoldShot_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671158);
		NobetaAnimatorController.NativeMethodInfoPtr_GetNorFireWeight_Public_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671159);
		NobetaAnimatorController.NativeMethodInfoPtr_SetNorFireWeightZero_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671160);
		NobetaAnimatorController.NativeMethodInfoPtr_SetFear_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671161);
		NobetaAnimatorController.NativeMethodInfoPtr_SetHeadHeight_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671162);
		NobetaAnimatorController.NativeMethodInfoPtr_SetSpeakLayerWeight_Public_Void_Boolean_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671163);
		NobetaAnimatorController.NativeMethodInfoPtr_SetWindLayer_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671164);
		NobetaAnimatorController.NativeMethodInfoPtr_SetPreyAnimation_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671165);
		NobetaAnimatorController.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaAnimatorController>.NativeClassPtr, 100671166);
	}

	// Token: 0x06006AE4 RID: 27364 RVA: 0x0000A688 File Offset: 0x00008888
	public NobetaAnimatorController(IntPtr pointer)
		: base(pointer)
	{
	}

	// Token: 0x17002511 RID: 9489
	// (get) Token: 0x06006AE5 RID: 27365 RVA: 0x001B2010 File Offset: 0x001B0210
	// (set) Token: 0x06006AE6 RID: 27366 RVA: 0x001B2044 File Offset: 0x001B0244
	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: 0x17002512 RID: 9490
	// (get) Token: 0x06006AE7 RID: 27367 RVA: 0x001B206C File Offset: 0x001B026C
	// (set) Token: 0x06006AE8 RID: 27368 RVA: 0x001B20A0 File Offset: 0x001B02A0
	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: 0x17002513 RID: 9491
	// (get) Token: 0x06006AE9 RID: 27369 RVA: 0x001B20C8 File Offset: 0x001B02C8
	// (set) Token: 0x06006AEA RID: 27370 RVA: 0x001B20F0 File Offset: 0x001B02F0
	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: 0x17002514 RID: 9492
	// (get) Token: 0x06006AEB RID: 27371 RVA: 0x001B2114 File Offset: 0x001B0314
	// (set) Token: 0x06006AEC RID: 27372 RVA: 0x001B213C File Offset: 0x001B033C
	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: 0x17002515 RID: 9493
	// (get) Token: 0x06006AED RID: 27373 RVA: 0x001B2160 File Offset: 0x001B0360
	// (set) Token: 0x06006AEE RID: 27374 RVA: 0x001B2188 File Offset: 0x001B0388
	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: 0x17002516 RID: 9494
	// (get) Token: 0x06006AEF RID: 27375 RVA: 0x001B21AC File Offset: 0x001B03AC
	// (set) Token: 0x06006AF0 RID: 27376 RVA: 0x001B21D4 File Offset: 0x001B03D4
	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: 0x17002517 RID: 9495
	// (get) Token: 0x06006AF1 RID: 27377 RVA: 0x001B21F8 File Offset: 0x001B03F8
	// (set) Token: 0x06006AF2 RID: 27378 RVA: 0x001B2220 File Offset: 0x001B0420
	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: 0x17002518 RID: 9496
	// (get) Token: 0x06006AF3 RID: 27379 RVA: 0x001B2244 File Offset: 0x001B0444
	// (set) Token: 0x06006AF4 RID: 27380 RVA: 0x001B226C File Offset: 0x001B046C
	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: 0x17002519 RID: 9497
	// (get) Token: 0x06006AF5 RID: 27381 RVA: 0x001B2290 File Offset: 0x001B0490
	// (set) Token: 0x06006AF6 RID: 27382 RVA: 0x001B22B8 File Offset: 0x001B04B8
	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: 0x1700251A RID: 9498
	// (get) Token: 0x06006AF7 RID: 27383 RVA: 0x001B22DC File Offset: 0x001B04DC
	// (set) Token: 0x06006AF8 RID: 27384 RVA: 0x001B2304 File Offset: 0x001B0504
	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: 0x1700251B RID: 9499
	// (get) Token: 0x06006AF9 RID: 27385 RVA: 0x001B2328 File Offset: 0x001B0528
	// (set) Token: 0x06006AFA RID: 27386 RVA: 0x001B2350 File Offset: 0x001B0550
	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: 0x1700251C RID: 9500
	// (get) Token: 0x06006AFB RID: 27387 RVA: 0x001B2374 File Offset: 0x001B0574
	// (set) Token: 0x06006AFC RID: 27388 RVA: 0x001B239C File Offset: 0x001B059C
	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: 0x1700251D RID: 9501
	// (get) Token: 0x06006AFD RID: 27389 RVA: 0x001B23C0 File Offset: 0x001B05C0
	// (set) Token: 0x06006AFE RID: 27390 RVA: 0x001B23E8 File Offset: 0x001B05E8
	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: 0x1700251E RID: 9502
	// (get) Token: 0x06006AFF RID: 27391 RVA: 0x001B240C File Offset: 0x001B060C
	// (set) Token: 0x06006B00 RID: 27392 RVA: 0x001B2434 File Offset: 0x001B0634
	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: 0x1700251F RID: 9503
	// (get) Token: 0x06006B01 RID: 27393 RVA: 0x001B2458 File Offset: 0x001B0658
	// (set) Token: 0x06006B02 RID: 27394 RVA: 0x001B2480 File Offset: 0x001B0680
	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: 0x17002520 RID: 9504
	// (get) Token: 0x06006B03 RID: 27395 RVA: 0x001B24A4 File Offset: 0x001B06A4
	// (set) Token: 0x06006B04 RID: 27396 RVA: 0x001B24CC File Offset: 0x001B06CC
	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: 0x17002521 RID: 9505
	// (get) Token: 0x06006B05 RID: 27397 RVA: 0x001B24F0 File Offset: 0x001B06F0
	// (set) Token: 0x06006B06 RID: 27398 RVA: 0x001B2518 File Offset: 0x001B0718
	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: 0x17002522 RID: 9506
	// (get) Token: 0x06006B07 RID: 27399 RVA: 0x001B253C File Offset: 0x001B073C
	// (set) Token: 0x06006B08 RID: 27400 RVA: 0x001B2564 File Offset: 0x001B0764
	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: 0x17002523 RID: 9507
	// (get) Token: 0x06006B09 RID: 27401 RVA: 0x001B2588 File Offset: 0x001B0788
	// (set) Token: 0x06006B0A RID: 27402 RVA: 0x001B25B0 File Offset: 0x001B07B0
	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: 0x17002524 RID: 9508
	// (get) Token: 0x06006B0B RID: 27403 RVA: 0x001B25D4 File Offset: 0x001B07D4
	// (set) Token: 0x06006B0C RID: 27404 RVA: 0x001B25FC File Offset: 0x001B07FC
	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: 0x17002525 RID: 9509
	// (get) Token: 0x06006B0D RID: 27405 RVA: 0x001B2620 File Offset: 0x001B0820
	// (set) Token: 0x06006B0E RID: 27406 RVA: 0x001B2648 File Offset: 0x001B0848
	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: 0x17002526 RID: 9510
	// (get) Token: 0x06006B0F RID: 27407 RVA: 0x001B266C File Offset: 0x001B086C
	// (set) Token: 0x06006B10 RID: 27408 RVA: 0x001B2694 File Offset: 0x001B0894
	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: 0x17002527 RID: 9511
	// (get) Token: 0x06006B11 RID: 27409 RVA: 0x001B26B8 File Offset: 0x001B08B8
	// (set) Token: 0x06006B12 RID: 27410 RVA: 0x001B26E0 File Offset: 0x001B08E0
	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: 0x17002528 RID: 9512
	// (get) Token: 0x06006B13 RID: 27411 RVA: 0x001B2704 File Offset: 0x001B0904
	// (set) Token: 0x06006B14 RID: 27412 RVA: 0x001B272C File Offset: 0x001B092C
	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: 0x17002529 RID: 9513
	// (get) Token: 0x06006B15 RID: 27413 RVA: 0x001B2750 File Offset: 0x001B0950
	// (set) Token: 0x06006B16 RID: 27414 RVA: 0x001B2778 File Offset: 0x001B0978
	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: 0x1700252A RID: 9514
	// (get) Token: 0x06006B17 RID: 27415 RVA: 0x001B279C File Offset: 0x001B099C
	// (set) Token: 0x06006B18 RID: 27416 RVA: 0x001B27C4 File Offset: 0x001B09C4
	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: 0x1700252B RID: 9515
	// (get) Token: 0x06006B19 RID: 27417 RVA: 0x001B27E8 File Offset: 0x001B09E8
	// (set) Token: 0x06006B1A RID: 27418 RVA: 0x001B2810 File Offset: 0x001B0A10
	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: 0x1700252C RID: 9516
	// (get) Token: 0x06006B1B RID: 27419 RVA: 0x001B2834 File Offset: 0x001B0A34
	// (set) Token: 0x06006B1C RID: 27420 RVA: 0x001B285C File Offset: 0x001B0A5C
	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: 0x1700252D RID: 9517
	// (get) Token: 0x06006B1D RID: 27421 RVA: 0x001B2880 File Offset: 0x001B0A80
	// (set) Token: 0x06006B1E RID: 27422 RVA: 0x001B28A8 File Offset: 0x001B0AA8
	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: 0x1700252E RID: 9518
	// (get) Token: 0x06006B1F RID: 27423 RVA: 0x001B28CC File Offset: 0x001B0ACC
	// (set) Token: 0x06006B20 RID: 27424 RVA: 0x001B28F4 File Offset: 0x001B0AF4
	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: 0x1700252F RID: 9519
	// (get) Token: 0x06006B21 RID: 27425 RVA: 0x001B2918 File Offset: 0x001B0B18
	// (set) Token: 0x06006B22 RID: 27426 RVA: 0x001B2940 File Offset: 0x001B0B40
	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: 0x17002530 RID: 9520
	// (get) Token: 0x06006B23 RID: 27427 RVA: 0x001B2964 File Offset: 0x001B0B64
	// (set) Token: 0x06006B24 RID: 27428 RVA: 0x001B298C File Offset: 0x001B0B8C
	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: 0x17002531 RID: 9521
	// (get) Token: 0x06006B25 RID: 27429 RVA: 0x001B29B0 File Offset: 0x001B0BB0
	// (set) Token: 0x06006B26 RID: 27430 RVA: 0x001B29D8 File Offset: 0x001B0BD8
	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: 0x17002532 RID: 9522
	// (get) Token: 0x06006B27 RID: 27431 RVA: 0x001B29FC File Offset: 0x001B0BFC
	// (set) Token: 0x06006B28 RID: 27432 RVA: 0x001B2A24 File Offset: 0x001B0C24
	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: 0x17002533 RID: 9523
	// (get) Token: 0x06006B29 RID: 27433 RVA: 0x001B2A48 File Offset: 0x001B0C48
	// (set) Token: 0x06006B2A RID: 27434 RVA: 0x001B2A70 File Offset: 0x001B0C70
	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: 0x17002534 RID: 9524
	// (get) Token: 0x06006B2B RID: 27435 RVA: 0x001B2A94 File Offset: 0x001B0C94
	// (set) Token: 0x06006B2C RID: 27436 RVA: 0x001B2ABC File Offset: 0x001B0CBC
	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: 0x17002535 RID: 9525
	// (get) Token: 0x06006B2D RID: 27437 RVA: 0x001B2AE0 File Offset: 0x001B0CE0
	// (set) Token: 0x06006B2E RID: 27438 RVA: 0x001B2B08 File Offset: 0x001B0D08
	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: 0x17002536 RID: 9526
	// (get) Token: 0x06006B2F RID: 27439 RVA: 0x001B2B2C File Offset: 0x001B0D2C
	// (set) Token: 0x06006B30 RID: 27440 RVA: 0x001B2B54 File Offset: 0x001B0D54
	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: 0x17002537 RID: 9527
	// (get) Token: 0x06006B31 RID: 27441 RVA: 0x001B2B78 File Offset: 0x001B0D78
	// (set) Token: 0x06006B32 RID: 27442 RVA: 0x001B2BA0 File Offset: 0x001B0DA0
	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: 0x17002538 RID: 9528
	// (get) Token: 0x06006B33 RID: 27443 RVA: 0x001B2BC4 File Offset: 0x001B0DC4
	// (set) Token: 0x06006B34 RID: 27444 RVA: 0x001B2BEC File Offset: 0x001B0DEC
	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: 0x17002539 RID: 9529
	// (get) Token: 0x06006B35 RID: 27445 RVA: 0x001B2C10 File Offset: 0x001B0E10
	// (set) Token: 0x06006B36 RID: 27446 RVA: 0x001B2C38 File Offset: 0x001B0E38
	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: 0x1700253A RID: 9530
	// (get) Token: 0x06006B37 RID: 27447 RVA: 0x001B2C5C File Offset: 0x001B0E5C
	// (set) Token: 0x06006B38 RID: 27448 RVA: 0x001B2C84 File Offset: 0x001B0E84
	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: 0x1700253B RID: 9531
	// (get) Token: 0x06006B39 RID: 27449 RVA: 0x001B2CA8 File Offset: 0x001B0EA8
	// (set) Token: 0x06006B3A RID: 27450 RVA: 0x001B2CD0 File Offset: 0x001B0ED0
	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: 0x1700253C RID: 9532
	// (get) Token: 0x06006B3B RID: 27451 RVA: 0x001B2CF4 File Offset: 0x001B0EF4
	// (set) Token: 0x06006B3C RID: 27452 RVA: 0x001B2D1C File Offset: 0x001B0F1C
	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: 0x1700253D RID: 9533
	// (get) Token: 0x06006B3D RID: 27453 RVA: 0x001B2D40 File Offset: 0x001B0F40
	// (set) Token: 0x06006B3E RID: 27454 RVA: 0x001B2D68 File Offset: 0x001B0F68
	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: 0x1700253E RID: 9534
	// (get) Token: 0x06006B3F RID: 27455 RVA: 0x001B2D8C File Offset: 0x001B0F8C
	// (set) Token: 0x06006B40 RID: 27456 RVA: 0x001B2DB4 File Offset: 0x001B0FB4
	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: 0x1700253F RID: 9535
	// (get) Token: 0x06006B41 RID: 27457 RVA: 0x001B2DD8 File Offset: 0x001B0FD8
	// (set) Token: 0x06006B42 RID: 27458 RVA: 0x001B2E00 File Offset: 0x001B1000
	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: 0x17002540 RID: 9536
	// (get) Token: 0x06006B43 RID: 27459 RVA: 0x001B2E24 File Offset: 0x001B1024
	// (set) Token: 0x06006B44 RID: 27460 RVA: 0x001B2E4C File Offset: 0x001B104C
	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: 0x17002541 RID: 9537
	// (get) Token: 0x06006B45 RID: 27461 RVA: 0x001B2E70 File Offset: 0x001B1070
	// (set) Token: 0x06006B46 RID: 27462 RVA: 0x001B2E98 File Offset: 0x001B1098
	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: 0x17002542 RID: 9538
	// (get) Token: 0x06006B47 RID: 27463 RVA: 0x001B2EBC File Offset: 0x001B10BC
	// (set) Token: 0x06006B48 RID: 27464 RVA: 0x001B2EE4 File Offset: 0x001B10E4
	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: 0x17002543 RID: 9539
	// (get) Token: 0x06006B49 RID: 27465 RVA: 0x001B2F08 File Offset: 0x001B1108
	// (set) Token: 0x06006B4A RID: 27466 RVA: 0x001B2F30 File Offset: 0x001B1130
	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: 0x17002544 RID: 9540
	// (get) Token: 0x06006B4B RID: 27467 RVA: 0x001B2F54 File Offset: 0x001B1154
	// (set) Token: 0x06006B4C RID: 27468 RVA: 0x001B2F7C File Offset: 0x001B117C
	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: 0x17002545 RID: 9541
	// (get) Token: 0x06006B4D RID: 27469 RVA: 0x001B2FA0 File Offset: 0x001B11A0
	// (set) Token: 0x06006B4E RID: 27470 RVA: 0x001B2FC8 File Offset: 0x001B11C8
	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: 0x17002546 RID: 9542
	// (get) Token: 0x06006B4F RID: 27471 RVA: 0x001B2FEC File Offset: 0x001B11EC
	// (set) Token: 0x06006B50 RID: 27472 RVA: 0x001B3014 File Offset: 0x001B1214
	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: 0x17002547 RID: 9543
	// (get) Token: 0x06006B51 RID: 27473 RVA: 0x001B3038 File Offset: 0x001B1238
	// (set) Token: 0x06006B52 RID: 27474 RVA: 0x001B3060 File Offset: 0x001B1260
	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: 0x17002548 RID: 9544
	// (get) Token: 0x06006B53 RID: 27475 RVA: 0x001B3084 File Offset: 0x001B1284
	// (set) Token: 0x06006B54 RID: 27476 RVA: 0x001B30AC File Offset: 0x001B12AC
	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: 0x17002549 RID: 9545
	// (get) Token: 0x06006B55 RID: 27477 RVA: 0x001B30D0 File Offset: 0x001B12D0
	// (set) Token: 0x06006B56 RID: 27478 RVA: 0x001B30F8 File Offset: 0x001B12F8
	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: 0x1700254A RID: 9546
	// (get) Token: 0x06006B57 RID: 27479 RVA: 0x001B311C File Offset: 0x001B131C
	// (set) Token: 0x06006B58 RID: 27480 RVA: 0x001B3144 File Offset: 0x001B1344
	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: 0x1700254B RID: 9547
	// (get) Token: 0x06006B59 RID: 27481 RVA: 0x001B3168 File Offset: 0x001B1368
	// (set) Token: 0x06006B5A RID: 27482 RVA: 0x001B3190 File Offset: 0x001B1390
	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: 0x1700254C RID: 9548
	// (get) Token: 0x06006B5B RID: 27483 RVA: 0x001B31B4 File Offset: 0x001B13B4
	// (set) Token: 0x06006B5C RID: 27484 RVA: 0x001B31DC File Offset: 0x001B13DC
	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: 0x1700254D RID: 9549
	// (get) Token: 0x06006B5D RID: 27485 RVA: 0x001B3200 File Offset: 0x001B1400
	// (set) Token: 0x06006B5E RID: 27486 RVA: 0x001B3228 File Offset: 0x001B1428
	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: 0x1700254E RID: 9550
	// (get) Token: 0x06006B5F RID: 27487 RVA: 0x001B324C File Offset: 0x001B144C
	// (set) Token: 0x06006B60 RID: 27488 RVA: 0x001B3274 File Offset: 0x001B1474
	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: 0x1700254F RID: 9551
	// (get) Token: 0x06006B61 RID: 27489 RVA: 0x001B3298 File Offset: 0x001B1498
	// (set) Token: 0x06006B62 RID: 27490 RVA: 0x001B32C0 File Offset: 0x001B14C0
	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: 0x17002550 RID: 9552
	// (get) Token: 0x06006B63 RID: 27491 RVA: 0x001B32E4 File Offset: 0x001B14E4
	// (set) Token: 0x06006B64 RID: 27492 RVA: 0x001B330C File Offset: 0x001B150C
	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: 0x17002551 RID: 9553
	// (get) Token: 0x06006B65 RID: 27493 RVA: 0x001B3330 File Offset: 0x001B1530
	// (set) Token: 0x06006B66 RID: 27494 RVA: 0x001B3358 File Offset: 0x001B1558
	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: 0x17002552 RID: 9554
	// (get) Token: 0x06006B67 RID: 27495 RVA: 0x001B337C File Offset: 0x001B157C
	// (set) Token: 0x06006B68 RID: 27496 RVA: 0x001B33A4 File Offset: 0x001B15A4
	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: 0x17002553 RID: 9555
	// (get) Token: 0x06006B69 RID: 27497 RVA: 0x001B33C8 File Offset: 0x001B15C8
	// (set) Token: 0x06006B6A RID: 27498 RVA: 0x001B33F0 File Offset: 0x001B15F0
	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: 0x17002554 RID: 9556
	// (get) Token: 0x06006B6B RID: 27499 RVA: 0x001B3414 File Offset: 0x001B1614
	// (set) Token: 0x06006B6C RID: 27500 RVA: 0x001B343C File Offset: 0x001B163C
	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: 0x17002555 RID: 9557
	// (get) Token: 0x06006B6D RID: 27501 RVA: 0x001B3460 File Offset: 0x001B1660
	// (set) Token: 0x06006B6E RID: 27502 RVA: 0x001B3488 File Offset: 0x001B1688
	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: 0x17002556 RID: 9558
	// (get) Token: 0x06006B6F RID: 27503 RVA: 0x001B34AC File Offset: 0x001B16AC
	// (set) Token: 0x06006B70 RID: 27504 RVA: 0x001B34D4 File Offset: 0x001B16D4
	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: 0x17002557 RID: 9559
	// (get) Token: 0x06006B71 RID: 27505 RVA: 0x001B34F8 File Offset: 0x001B16F8
	// (set) Token: 0x06006B72 RID: 27506 RVA: 0x001B3520 File Offset: 0x001B1720
	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: 0x17002558 RID: 9560
	// (get) Token: 0x06006B73 RID: 27507 RVA: 0x001B3544 File Offset: 0x001B1744
	// (set) Token: 0x06006B74 RID: 27508 RVA: 0x001B356C File Offset: 0x001B176C
	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: 0x17002559 RID: 9561
	// (get) Token: 0x06006B75 RID: 27509 RVA: 0x001B3590 File Offset: 0x001B1790
	// (set) Token: 0x06006B76 RID: 27510 RVA: 0x001B35B8 File Offset: 0x001B17B8
	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: 0x1700255A RID: 9562
	// (get) Token: 0x06006B77 RID: 27511 RVA: 0x001B35DC File Offset: 0x001B17DC
	// (set) Token: 0x06006B78 RID: 27512 RVA: 0x001B3604 File Offset: 0x001B1804
	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: 0x1700255B RID: 9563
	// (get) Token: 0x06006B79 RID: 27513 RVA: 0x001B3628 File Offset: 0x001B1828
	// (set) Token: 0x06006B7A RID: 27514 RVA: 0x001B3650 File Offset: 0x001B1850
	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: 0x1700255C RID: 9564
	// (get) Token: 0x06006B7B RID: 27515 RVA: 0x001B3674 File Offset: 0x001B1874
	// (set) Token: 0x06006B7C RID: 27516 RVA: 0x001B369C File Offset: 0x001B189C
	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: 0x1700255D RID: 9565
	// (get) Token: 0x06006B7D RID: 27517 RVA: 0x001B36C0 File Offset: 0x001B18C0
	// (set) Token: 0x06006B7E RID: 27518 RVA: 0x001B36E8 File Offset: 0x001B18E8
	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: 0x1700255E RID: 9566
	// (get) Token: 0x06006B7F RID: 27519 RVA: 0x001B370C File Offset: 0x001B190C
	// (set) Token: 0x06006B80 RID: 27520 RVA: 0x001B3734 File Offset: 0x001B1934
	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: 0x1700255F RID: 9567
	// (get) Token: 0x06006B81 RID: 27521 RVA: 0x001B3758 File Offset: 0x001B1958
	// (set) Token: 0x06006B82 RID: 27522 RVA: 0x001B3780 File Offset: 0x001B1980
	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: 0x040046ED RID: 18157
	private static readonly IntPtr NativeFieldInfoPtr_mainAnimator;

	// Token: 0x040046EE RID: 18158
	private static readonly IntPtr NativeFieldInfoPtr_faceAnimator;

	// Token: 0x040046EF RID: 18159
	private static readonly IntPtr NativeFieldInfoPtr_aimWeight;

	// Token: 0x040046F0 RID: 18160
	private static readonly IntPtr NativeFieldInfoPtr_aimReadyWeight;

	// Token: 0x040046F1 RID: 18161
	private static readonly IntPtr NativeFieldInfoPtr_fireLayerWeight;

	// Token: 0x040046F2 RID: 18162
	private static readonly IntPtr NativeFieldInfoPtr_fireLayerStayTime;

	// Token: 0x040046F3 RID: 18163
	private static readonly IntPtr NativeFieldInfoPtr_moveSpeed;

	// Token: 0x040046F4 RID: 18164
	private static readonly IntPtr NativeFieldInfoPtr_moveAngle;

	// Token: 0x040046F5 RID: 18165
	private static readonly IntPtr NativeFieldInfoPtr_moveHorizontal;

	// Token: 0x040046F6 RID: 18166
	private static readonly IntPtr NativeFieldInfoPtr_moveVertical;

	// Token: 0x040046F7 RID: 18167
	private static readonly IntPtr NativeFieldInfoPtr_scriptMovement;

	// Token: 0x040046F8 RID: 18168
	private static readonly IntPtr NativeFieldInfoPtr_isBattleState;

	// Token: 0x040046F9 RID: 18169
	private static readonly IntPtr NativeFieldInfoPtr_battleTime;

	// Token: 0x040046FA RID: 18170
	private static readonly IntPtr NativeFieldInfoPtr_isIdleRandom;

	// Token: 0x040046FB RID: 18171
	private static readonly IntPtr NativeFieldInfoPtr_idleTime;

	// Token: 0x040046FC RID: 18172
	private static readonly IntPtr NativeFieldInfoPtr_battleFace;

	// Token: 0x040046FD RID: 18173
	private static readonly IntPtr NativeFieldInfoPtr_skyStayTime;

	// Token: 0x040046FE RID: 18174
	private static readonly IntPtr NativeFieldInfoPtr_norFireWeight;

	// Token: 0x040046FF RID: 18175
	private static readonly IntPtr NativeFieldInfoPtr_norFireStayTime;

	// Token: 0x04004700 RID: 18176
	private static readonly IntPtr NativeFieldInfoPtr_charge;

	// Token: 0x04004701 RID: 18177
	private static readonly IntPtr NativeFieldInfoPtr_chargeValue;

	// Token: 0x04004702 RID: 18178
	private static readonly IntPtr NativeFieldInfoPtr_useItem;

	// Token: 0x04004703 RID: 18179
	private static readonly IntPtr NativeFieldInfoPtr_useItemValue;

	// Token: 0x04004704 RID: 18180
	private static readonly IntPtr NativeFieldInfoPtr_holdShot;

	// Token: 0x04004705 RID: 18181
	private static readonly IntPtr NativeFieldInfoPtr_norFireAngle;

	// Token: 0x04004706 RID: 18182
	private static readonly IntPtr NativeFieldInfoPtr_act01IdleHead;

	// Token: 0x04004707 RID: 18183
	private static readonly IntPtr NativeFieldInfoPtr_act01IdleHeadSet;

	// Token: 0x04004708 RID: 18184
	private static readonly IntPtr NativeFieldInfoPtr_windLayerEnable;

	// Token: 0x04004709 RID: 18185
	private static readonly IntPtr NativeFieldInfoPtr_windLayerWeight;

	// Token: 0x0400470A RID: 18186
	private static readonly IntPtr NativeFieldInfoPtr_timeScale;

	// Token: 0x0400470B RID: 18187
	private static readonly IntPtr NativeFieldInfoPtr_battleTimeMax;

	// Token: 0x0400470C RID: 18188
	private static readonly IntPtr NativeFieldInfoPtr_IdleTimeMax;

	// Token: 0x0400470D RID: 18189
	private static readonly IntPtr NativeFieldInfoPtr_switchIdleStateHash;

	// Token: 0x0400470E RID: 18190
	private static readonly IntPtr NativeFieldInfoPtr_idleRandom01StateHash;

	// Token: 0x0400470F RID: 18191
	private static readonly IntPtr NativeFieldInfoPtr_idleRandom02StateHash;

	// Token: 0x04004710 RID: 18192
	private static readonly IntPtr NativeFieldInfoPtr_brakingBattleStateHash;

	// Token: 0x04004711 RID: 18193
	private static readonly IntPtr NativeFieldInfoPtr_brakingStateHash;

	// Token: 0x04004712 RID: 18194
	private static readonly IntPtr NativeFieldInfoPtr_dodgeForwardStateHash;

	// Token: 0x04004713 RID: 18195
	private static readonly IntPtr NativeFieldInfoPtr_dodgeBackwardStateHash;

	// Token: 0x04004714 RID: 18196
	private static readonly IntPtr NativeFieldInfoPtr_heightLandBattleStateHash;

	// Token: 0x04004715 RID: 18197
	private static readonly IntPtr NativeFieldInfoPtr_heightLandStateHash;

	// Token: 0x04004716 RID: 18198
	private static readonly IntPtr NativeFieldInfoPtr_landBattleStateHash;

	// Token: 0x04004717 RID: 18199
	private static readonly IntPtr NativeFieldInfoPtr_landStateHash;

	// Token: 0x04004718 RID: 18200
	private static readonly IntPtr NativeFieldInfoPtr_pickUpStateHash;

	// Token: 0x04004719 RID: 18201
	private static readonly IntPtr NativeFieldInfoPtr_discardItemStateHash;

	// Token: 0x0400471A RID: 18202
	private static readonly IntPtr NativeFieldInfoPtr_lightUpStateHash;

	// Token: 0x0400471B RID: 18203
	private static readonly IntPtr NativeFieldInfoPtr_stage4LightBallStateHash;

	// Token: 0x0400471C RID: 18204
	private static readonly IntPtr NativeFieldInfoPtr_switchOnStateHash;

	// Token: 0x0400471D RID: 18205
	private static readonly IntPtr NativeFieldInfoPtr_idleToPrayStateHash;

	// Token: 0x0400471E RID: 18206
	private static readonly IntPtr NativeFieldInfoPtr_idleToPrayHeadUpStateHash;

	// Token: 0x0400471F RID: 18207
	private static readonly IntPtr NativeFieldInfoPtr_preyToIdleStateHash;

	// Token: 0x04004720 RID: 18208
	private static readonly IntPtr NativeFieldInfoPtr_idleStateHash;

	// Token: 0x04004721 RID: 18209
	private static readonly IntPtr NativeFieldInfoPtr_aimShotStateHash;

	// Token: 0x04004722 RID: 18210
	private static readonly IntPtr NativeFieldInfoPtr_aimNullShotStateHash;

	// Token: 0x04004723 RID: 18211
	private static readonly IntPtr NativeFieldInfoPtr_jumpBattleStateHash;

	// Token: 0x04004724 RID: 18212
	private static readonly IntPtr NativeFieldInfoPtr_jumpStateHash;

	// Token: 0x04004725 RID: 18213
	private static readonly IntPtr NativeFieldInfoPtr_skyJumpBattleStateHash;

	// Token: 0x04004726 RID: 18214
	private static readonly IntPtr NativeFieldInfoPtr_skyJumpStateHash;

	// Token: 0x04004727 RID: 18215
	private static readonly IntPtr NativeFieldInfoPtr_fallBattleStateHash;

	// Token: 0x04004728 RID: 18216
	private static readonly IntPtr NativeFieldInfoPtr_fallStateHash;

	// Token: 0x04004729 RID: 18217
	private static readonly IntPtr NativeFieldInfoPtr_speakNormalStateHash;

	// Token: 0x0400472A RID: 18218
	private static readonly IntPtr NativeFieldInfoPtr_speakHappyStateHash;

	// Token: 0x0400472B RID: 18219
	private static readonly IntPtr NativeFieldInfoPtr_speakLoudlyStateHash;

	// Token: 0x0400472C RID: 18220
	private static readonly IntPtr NativeFieldInfoPtr_moveSpeedHash;

	// Token: 0x0400472D RID: 18221
	private static readonly IntPtr NativeFieldInfoPtr_fearHash;

	// Token: 0x0400472E RID: 18222
	private static readonly IntPtr NativeFieldInfoPtr_moveAngleHash;

	// Token: 0x0400472F RID: 18223
	private static readonly IntPtr NativeFieldInfoPtr_moveHorizontalHash;

	// Token: 0x04004730 RID: 18224
	private static readonly IntPtr NativeFieldInfoPtr_moveVerticalHash;

	// Token: 0x04004731 RID: 18225
	private static readonly IntPtr NativeFieldInfoPtr_isSkyHash;

	// Token: 0x04004732 RID: 18226
	private static readonly IntPtr NativeFieldInfoPtr_aimReadyHash;

	// Token: 0x04004733 RID: 18227
	private static readonly IntPtr NativeFieldInfoPtr_aimHash;

	// Token: 0x04004734 RID: 18228
	private static readonly IntPtr NativeFieldInfoPtr_isBattleHash;

	// Token: 0x04004735 RID: 18229
	private static readonly IntPtr NativeFieldInfoPtr_battleHash;

	// Token: 0x04004736 RID: 18230
	private static readonly IntPtr NativeFieldInfoPtr_norFireAngleHash;

	// Token: 0x04004737 RID: 18231
	private static readonly IntPtr NativeFieldInfoPtr_chargeHash;

	// Token: 0x04004738 RID: 18232
	private static readonly IntPtr NativeFieldInfoPtr_useItemHash;

	// Token: 0x04004739 RID: 18233
	private static readonly IntPtr NativeFieldInfoPtr_chargeMaxHash;

	// Token: 0x0400473A RID: 18234
	private static readonly IntPtr NativeFieldInfoPtr_holdShotHash;

	// Token: 0x0400473B RID: 18235
	private static readonly IntPtr NativeFieldInfoPtr_act01IdleHeadHash;

	// Token: 0x0400473C RID: 18236
	private static readonly IntPtr NativeMethodInfoPtr_Init_Public_Void_Animator_Animator_0;

	// Token: 0x0400473D RID: 18237
	private static readonly IntPtr NativeMethodInfoPtr_Update_Public_Void_NobetaAnimatorData_0;

	// Token: 0x0400473E RID: 18238
	private static readonly IntPtr NativeMethodInfoPtr_PlayBraking_Public_Void_0;

	// Token: 0x0400473F RID: 18239
	private static readonly IntPtr NativeMethodInfoPtr_PlayDodgeForward_Public_Void_0;

	// Token: 0x04004740 RID: 18240
	private static readonly IntPtr NativeMethodInfoPtr_PlayDodgeBack_Public_Void_0;

	// Token: 0x04004741 RID: 18241
	private static readonly IntPtr NativeMethodInfoPtr_PlayJump_Public_Void_Single_Single_0;

	// Token: 0x04004742 RID: 18242
	private static readonly IntPtr NativeMethodInfoPtr_PlaySkyJump_Public_Void_Single_Single_0;

	// Token: 0x04004743 RID: 18243
	private static readonly IntPtr NativeMethodInfoPtr_PlayFall_Public_Void_0;

	// Token: 0x04004744 RID: 18244
	private static readonly IntPtr NativeMethodInfoPtr_PlayLand_Public_Void_Boolean_0;

	// Token: 0x04004745 RID: 18245
	private static readonly IntPtr NativeMethodInfoPtr_PlayPickUp_Public_Void_0;

	// Token: 0x04004746 RID: 18246
	private static readonly IntPtr NativeMethodInfoPtr_PlayDiscardItem_Public_Void_0;

	// Token: 0x04004747 RID: 18247
	private static readonly IntPtr NativeMethodInfoPtr_PlayOnLight_Public_Void_0;

	// Token: 0x04004748 RID: 18248
	private static readonly IntPtr NativeMethodInfoPtr_PlayLightBall_Public_Void_0;

	// Token: 0x04004749 RID: 18249
	private static readonly IntPtr NativeMethodInfoPtr_PlaySwitchOn_Public_Void_0;

	// Token: 0x0400474A RID: 18250
	private static readonly IntPtr NativeMethodInfoPtr_PlayPrayerStart_Public_Void_0;

	// Token: 0x0400474B RID: 18251
	private static readonly IntPtr NativeMethodInfoPtr_PlayPrayerEnd_Public_Void_0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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