NobetaSource/Interop/Assembly-CSharp/NobetaRuntimeData.cs

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

// Token: 0x02000304 RID: 772
[Serializable]
public class NobetaRuntimeData : Il2CppSystem.Object
{
	// Token: 0x170022E1 RID: 8929
	// (get) Token: 0x060064BF RID: 25791 RVA: 0x00198960 File Offset: 0x00196B60
	public unsafe bool Controllable
	{
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 6570, RefRangeEnd = 6571, XrefRangeStart = 6570, XrefRangeEnd = 6571, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_Controllable_Public_get_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x170022E2 RID: 8930
	// (get) Token: 0x060064C0 RID: 25792 RVA: 0x001989B0 File Offset: 0x00196BB0
	public unsafe bool IsDead
	{
		[CallerCount(0)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_IsDead_Public_get_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x170022E3 RID: 8931
	// (get) Token: 0x060064C1 RID: 25793 RVA: 0x00198A00 File Offset: 0x00196C00
	public unsafe float DeltaTime
	{
		[CallerCount(0)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_DeltaTime_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x170022E4 RID: 8932
	// (get) Token: 0x060064C2 RID: 25794 RVA: 0x00198A50 File Offset: 0x00196C50
	public unsafe float TimeScale
	{
		[CallerCount(0)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_TimeScale_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x170022E5 RID: 8933
	// (get) Token: 0x060064C3 RID: 25795 RVA: 0x00198AA0 File Offset: 0x00196CA0
	public unsafe float MoveSpeed
	{
		[CallerCount(0)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_MoveSpeed_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x170022E6 RID: 8934
	// (get) Token: 0x060064C4 RID: 25796 RVA: 0x00198AF0 File Offset: 0x00196CF0
	public unsafe float JumpMoveSpeed
	{
		[CallerCount(0)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_JumpMoveSpeed_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x170022E7 RID: 8935
	// (get) Token: 0x060064C5 RID: 25797 RVA: 0x00198B40 File Offset: 0x00196D40
	public unsafe float RotationSpeed
	{
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 575094, RefRangeEnd = 575095, XrefRangeStart = 575094, XrefRangeEnd = 575094, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_RotationSpeed_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x170022E8 RID: 8936
	// (get) Token: 0x060064C6 RID: 25798 RVA: 0x00198B90 File Offset: 0x00196D90
	public unsafe float MoveSpeedScale
	{
		[CallerCount(11)]
		[CachedScanResults(RefRangeStart = 575095, RefRangeEnd = 575106, XrefRangeStart = 575095, XrefRangeEnd = 575095, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_MoveSpeedScale_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x170022E9 RID: 8937
	// (get) Token: 0x060064C7 RID: 25799 RVA: 0x00198BE0 File Offset: 0x00196DE0
	public unsafe Vector3 MoveDirection
	{
		[CallerCount(0)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_MoveDirection_Public_get_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x170022EA RID: 8938
	// (get) Token: 0x060064C8 RID: 25800 RVA: 0x00198C30 File Offset: 0x00196E30
	public unsafe Vector3 JumpDirection
	{
		[CallerCount(0)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_JumpDirection_Public_get_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x170022EB RID: 8939
	// (get) Token: 0x060064C9 RID: 25801 RVA: 0x00198C80 File Offset: 0x00196E80
	public unsafe float JumpForce
	{
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 575106, RefRangeEnd = 575108, XrefRangeStart = 575106, XrefRangeEnd = 575106, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_JumpForce_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x170022EC RID: 8940
	// (get) Token: 0x060064CA RID: 25802 RVA: 0x00198CD0 File Offset: 0x00196ED0
	public unsafe float Gravity
	{
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 575108, RefRangeEnd = 575109, XrefRangeStart = 575108, XrefRangeEnd = 575108, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_Gravity_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x170022ED RID: 8941
	// (get) Token: 0x060064CB RID: 25803 RVA: 0x00198D20 File Offset: 0x00196F20
	public unsafe bool IsPond
	{
		[CallerCount(0)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_IsPond_Public_get_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x170022EE RID: 8942
	// (get) Token: 0x060064CC RID: 25804 RVA: 0x00198D70 File Offset: 0x00196F70
	public unsafe float PondHeight
	{
		[CallerCount(0)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_PondHeight_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x170022EF RID: 8943
	// (get) Token: 0x060064CD RID: 25805 RVA: 0x00198DC0 File Offset: 0x00196FC0
	public unsafe bool IsSky
	{
		[CallerCount(0)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_IsSky_Public_get_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x170022F0 RID: 8944
	// (get) Token: 0x060064CE RID: 25806 RVA: 0x00198E10 File Offset: 0x00197010
	public unsafe float FallSpeedMax
	{
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 575109, RefRangeEnd = 575110, XrefRangeStart = 575109, XrefRangeEnd = 575109, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_FallSpeedMax_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x170022F1 RID: 8945
	// (get) Token: 0x060064CF RID: 25807 RVA: 0x00198E60 File Offset: 0x00197060
	public unsafe float FallTimer
	{
		[CallerCount(0)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_FallTimer_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x170022F2 RID: 8946
	// (get) Token: 0x060064D0 RID: 25808 RVA: 0x00198EB0 File Offset: 0x001970B0
	public unsafe float AimReadyWight
	{
		[CallerCount(0)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_AimReadyWight_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x170022F3 RID: 8947
	// (get) Token: 0x060064D1 RID: 25809 RVA: 0x00198F00 File Offset: 0x00197100
	public unsafe float AimWight
	{
		[CallerCount(0)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_AimWight_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x170022F4 RID: 8948
	// (get) Token: 0x060064D2 RID: 25810 RVA: 0x00198F50 File Offset: 0x00197150
	// (set) Token: 0x060064D3 RID: 25811 RVA: 0x00198FA0 File Offset: 0x001971A0
	public unsafe float HoldingShot
	{
		[CallerCount(0)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_HoldingShot_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
		[CallerCount(0)]
		set
		{
			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(NobetaRuntimeData.NativeMethodInfoPtr_set_HoldingShot_Public_set_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}
		}
	}

	// Token: 0x170022F5 RID: 8949
	// (get) Token: 0x060064D4 RID: 25812 RVA: 0x00198FF4 File Offset: 0x001971F4
	public unsafe float HPRecovery
	{
		[CallerCount(0)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_HPRecovery_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x170022F6 RID: 8950
	// (get) Token: 0x060064D5 RID: 25813 RVA: 0x00199044 File Offset: 0x00197244
	public unsafe float MPRecovery
	{
		[CallerCount(0)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_MPRecovery_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x170022F7 RID: 8951
	// (get) Token: 0x060064D6 RID: 25814 RVA: 0x00199094 File Offset: 0x00197294
	public unsafe float MPRecoveryExternal
	{
		[CallerCount(0)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_MPRecoveryExternal_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x170022F8 RID: 8952
	// (get) Token: 0x060064D7 RID: 25815 RVA: 0x001990E4 File Offset: 0x001972E4
	public unsafe Il2CppReferenceArray<Transform> MagicLockTargets
	{
		[CallerCount(0)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_MagicLockTargets_Public_get_Il2CppReferenceArray_1_Transform_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			IntPtr intPtr3 = intPtr;
			return (intPtr3 != 0) ? new Il2CppReferenceArray<Transform>(intPtr3) : null;
		}
	}

	// Token: 0x170022F9 RID: 8953
	// (get) Token: 0x060064D8 RID: 25816 RVA: 0x0019913C File Offset: 0x0019733C
	public unsafe bool HasMagicLockTargets
	{
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 575110, RefRangeEnd = 575112, XrefRangeStart = 575110, XrefRangeEnd = 575110, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_HasMagicLockTargets_Public_get_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x170022FA RID: 8954
	// (get) Token: 0x060064D9 RID: 25817 RVA: 0x0019918C File Offset: 0x0019738C
	public unsafe float StaminaLossDodge
	{
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 575112, RefRangeEnd = 575114, XrefRangeStart = 575112, XrefRangeEnd = 575112, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_StaminaLossDodge_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x170022FB RID: 8955
	// (get) Token: 0x060064DA RID: 25818 RVA: 0x001991DC File Offset: 0x001973DC
	public unsafe float StaminaLossDash
	{
		[CallerCount(11)]
		[CachedScanResults(RefRangeStart = 575095, RefRangeEnd = 575106, XrefRangeStart = 575095, XrefRangeEnd = 575106, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_StaminaLossDash_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x170022FC RID: 8956
	// (get) Token: 0x060064DB RID: 25819 RVA: 0x0019922C File Offset: 0x0019742C
	public unsafe float StaminaLossFall
	{
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 575114, RefRangeEnd = 575115, XrefRangeStart = 575114, XrefRangeEnd = 575114, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_StaminaLossFall_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x170022FD RID: 8957
	// (get) Token: 0x060064DC RID: 25820 RVA: 0x0019927C File Offset: 0x0019747C
	public unsafe float StaminaLossJump
	{
		[CallerCount(11)]
		[CachedScanResults(RefRangeStart = 575095, RefRangeEnd = 575106, XrefRangeStart = 575095, XrefRangeEnd = 575106, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_StaminaLossJump_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x170022FE RID: 8958
	// (get) Token: 0x060064DD RID: 25821 RVA: 0x001992CC File Offset: 0x001974CC
	public unsafe float AbsorbTimer
	{
		[CallerCount(0)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_AbsorbTimer_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x170022FF RID: 8959
	// (get) Token: 0x060064DE RID: 25822 RVA: 0x0019931C File Offset: 0x0019751C
	public unsafe float AbsorbCDTimer
	{
		[CallerCount(0)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_AbsorbCDTimer_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x17002300 RID: 8960
	// (get) Token: 0x060064DF RID: 25823 RVA: 0x0019936C File Offset: 0x0019756C
	public unsafe float AbsorbStatusTimer
	{
		[CallerCount(0)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_AbsorbStatusTimer_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x17002301 RID: 8961
	// (get) Token: 0x060064E0 RID: 25824 RVA: 0x001993BC File Offset: 0x001975BC
	public unsafe bool IsSlip
	{
		[CallerCount(0)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_IsSlip_Public_get_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x17002302 RID: 8962
	// (get) Token: 0x060064E1 RID: 25825 RVA: 0x0019940C File Offset: 0x0019760C
	public unsafe bool IsChargeEnable
	{
		[CallerCount(0)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_IsChargeEnable_Public_get_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x17002303 RID: 8963
	// (get) Token: 0x060064E2 RID: 25826 RVA: 0x0019945C File Offset: 0x0019765C
	public unsafe float DodgeTimer
	{
		[CallerCount(0)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_DodgeTimer_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x17002304 RID: 8964
	// (get) Token: 0x060064E3 RID: 25827 RVA: 0x001994AC File Offset: 0x001976AC
	public unsafe float DamageDodgeTimer
	{
		[CallerCount(0)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_DamageDodgeTimer_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x17002305 RID: 8965
	// (get) Token: 0x060064E4 RID: 25828 RVA: 0x001994FC File Offset: 0x001976FC
	public unsafe bool ShotEffect
	{
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 24633, RefRangeEnd = 24634, XrefRangeStart = 24633, XrefRangeEnd = 24634, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_ShotEffect_Public_get_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x17002306 RID: 8966
	// (get) Token: 0x060064E5 RID: 25829 RVA: 0x0019954C File Offset: 0x0019774C
	public unsafe bool HardBody
	{
		[CallerCount(0)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_HardBody_Public_get_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x17002307 RID: 8967
	// (get) Token: 0x060064E6 RID: 25830 RVA: 0x0019959C File Offset: 0x0019779C
	public unsafe bool DodgeDamage
	{
		[CallerCount(0)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_DodgeDamage_Public_get_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x17002308 RID: 8968
	// (get) Token: 0x060064E7 RID: 25831 RVA: 0x001995EC File Offset: 0x001977EC
	public unsafe float PrayerAttackTimer
	{
		[CallerCount(0)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_PrayerAttackTimer_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x17002309 RID: 8969
	// (get) Token: 0x060064E8 RID: 25832 RVA: 0x0019963C File Offset: 0x0019783C
	public unsafe bool NextAttack
	{
		[CallerCount(0)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_NextAttack_Public_get_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x1700230A RID: 8970
	// (get) Token: 0x060064E9 RID: 25833 RVA: 0x0019968C File Offset: 0x0019788C
	public unsafe bool NextAirAttack
	{
		[CallerCount(0)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_NextAirAttack_Public_get_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x1700230B RID: 8971
	// (get) Token: 0x060064EA RID: 25834 RVA: 0x001996DC File Offset: 0x001978DC
	public unsafe float AirAttackTimer
	{
		[CallerCount(0)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_AirAttackTimer_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x1700230C RID: 8972
	// (get) Token: 0x060064EB RID: 25835 RVA: 0x0019972C File Offset: 0x0019792C
	public unsafe float WaitTime
	{
		[CallerCount(0)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_WaitTime_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x1700230D RID: 8973
	// (get) Token: 0x060064EC RID: 25836 RVA: 0x0019977C File Offset: 0x0019797C
	public unsafe float NoFireWaitTime
	{
		[CallerCount(0)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_NoFireWaitTime_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x1700230E RID: 8974
	// (get) Token: 0x060064ED RID: 25837 RVA: 0x001997CC File Offset: 0x001979CC
	public unsafe float AimTime
	{
		[CallerCount(0)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_AimTime_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x1700230F RID: 8975
	// (get) Token: 0x060064EE RID: 25838 RVA: 0x0019981C File Offset: 0x00197A1C
	public unsafe float ShotTime
	{
		[CallerCount(0)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_ShotTime_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x17002310 RID: 8976
	// (get) Token: 0x060064EF RID: 25839 RVA: 0x0019986C File Offset: 0x00197A6C
	public unsafe float NextTime
	{
		[CallerCount(0)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_NextTime_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x17002311 RID: 8977
	// (get) Token: 0x060064F0 RID: 25840 RVA: 0x001998BC File Offset: 0x00197ABC
	public unsafe float NextEndTime
	{
		[CallerCount(0)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_get_NextEndTime_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x060064F1 RID: 25841 RVA: 0x0019990C File Offset: 0x00197B0C
	[CallerCount(0)]
	public unsafe void UpdateControllable(bool controllable)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref controllable;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_UpdateControllable_Public_Void_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x060064F2 RID: 25842 RVA: 0x00199960 File Offset: 0x00197B60
	[CallerCount(0)]
	public unsafe void UpdateIsDead(bool isDead)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref isDead;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_UpdateIsDead_Public_Void_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x060064F3 RID: 25843 RVA: 0x001999B4 File Offset: 0x00197BB4
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 575119, RefRangeEnd = 575120, XrefRangeStart = 575115, XrefRangeEnd = 575119, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void UpdateTimeMembers(float deltaTime)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref deltaTime;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_UpdateTimeMembers_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x060064F4 RID: 25844 RVA: 0x00199A08 File Offset: 0x00197C08
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 216230, RefRangeEnd = 216234, XrefRangeStart = 216230, XrefRangeEnd = 216234, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void UpdateMoveSpeed(float speed)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref speed;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_UpdateMoveSpeed_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x060064F5 RID: 25845 RVA: 0x00199A5C File Offset: 0x00197C5C
	[CallerCount(0)]
	public unsafe void UpdateMoveDirection(Vector3 direction)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref direction;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_UpdateMoveDirection_Public_Void_Vector3_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x060064F6 RID: 25846 RVA: 0x00199AB0 File Offset: 0x00197CB0
	[CallerCount(0)]
	public unsafe void UpdateJumpDirection()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_UpdateJumpDirection_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x060064F7 RID: 25847 RVA: 0x00199AF4 File Offset: 0x00197CF4
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 575124, RefRangeEnd = 575125, XrefRangeStart = 575120, XrefRangeEnd = 575124, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void UpdateJumpDirection(Transform source)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = IL2CPP.Il2CppObjectBaseToPtr(source);
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_UpdateJumpDirection_Public_Void_Transform_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x060064F8 RID: 25848 RVA: 0x00199B50 File Offset: 0x00197D50
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 575125, RefRangeEnd = 575126, XrefRangeStart = 575125, XrefRangeEnd = 575125, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void IncreaseDamagedAirStayTimer()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_IncreaseDamagedAirStayTimer_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x060064F9 RID: 25849 RVA: 0x00199B94 File Offset: 0x00197D94
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 575126, RefRangeEnd = 575130, XrefRangeStart = 575126, XrefRangeEnd = 575126, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void ResetDamagedAirStayTimer()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_ResetDamagedAirStayTimer_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x060064FA RID: 25850 RVA: 0x00199BD8 File Offset: 0x00197DD8
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 218203, RefRangeEnd = 218204, XrefRangeStart = 218203, XrefRangeEnd = 218204, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void UpdateJumpMoveSpeed(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(NobetaRuntimeData.NativeMethodInfoPtr_UpdateJumpMoveSpeed_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x060064FB RID: 25851 RVA: 0x00199C2C File Offset: 0x00197E2C
	[CallerCount(0)]
	public unsafe void UpdateIsPond(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(NobetaRuntimeData.NativeMethodInfoPtr_UpdateIsPond_Public_Void_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x060064FC RID: 25852 RVA: 0x00199C80 File Offset: 0x00197E80
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 218253, RefRangeEnd = 218254, XrefRangeStart = 218253, XrefRangeEnd = 218254, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void UpdatePondHeight(float Height)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref Height;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_UpdatePondHeight_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x060064FD RID: 25853 RVA: 0x00199CD4 File Offset: 0x00197ED4
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 575130, RefRangeEnd = 575132, XrefRangeStart = 575130, XrefRangeEnd = 575130, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void UpdateIsSky(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(NobetaRuntimeData.NativeMethodInfoPtr_UpdateIsSky_Public_Void_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x060064FE RID: 25854 RVA: 0x00199D28 File Offset: 0x00197F28
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 575135, RefRangeEnd = 575136, XrefRangeStart = 575132, XrefRangeEnd = 575135, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void UpdateFallTimer(Transform source)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = IL2CPP.Il2CppObjectBaseToPtr(source);
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_UpdateFallTimer_Public_Void_Transform_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x060064FF RID: 25855 RVA: 0x00199D84 File Offset: 0x00197F84
	[CallerCount(0)]
	public unsafe void UpdateAimReadyWight(float aimReadyWight)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref aimReadyWight;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_UpdateAimReadyWight_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06006500 RID: 25856 RVA: 0x00199DD8 File Offset: 0x00197FD8
	[CallerCount(0)]
	public unsafe void UpdateAimWight(float aimWight)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref aimWight;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_UpdateAimWight_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06006501 RID: 25857 RVA: 0x00199E2C File Offset: 0x0019802C
	[CallerCount(9)]
	[CachedScanResults(RefRangeStart = 575136, RefRangeEnd = 575145, XrefRangeStart = 575136, XrefRangeEnd = 575136, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void ResetAimWightValues()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_ResetAimWightValues_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006502 RID: 25858 RVA: 0x00199E70 File Offset: 0x00198070
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 575145, RefRangeEnd = 575147, XrefRangeStart = 575145, XrefRangeEnd = 575145, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void UpdateHPRecovery(float delta)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref delta;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_UpdateHPRecovery_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06006503 RID: 25859 RVA: 0x00199EC4 File Offset: 0x001980C4
	[CallerCount(3)]
	[CachedScanResults(RefRangeStart = 575147, RefRangeEnd = 575150, XrefRangeStart = 575147, XrefRangeEnd = 575147, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void UpdateMPRecovery(float delta)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref delta;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_UpdateMPRecovery_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06006504 RID: 25860 RVA: 0x00199F18 File Offset: 0x00198118
	[CallerCount(0)]
	public unsafe void UpdateMPRecoveryExternal(float recovery)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref recovery;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_UpdateMPRecoveryExternal_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06006505 RID: 25861 RVA: 0x00199F6C File Offset: 0x0019816C
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 575157, RefRangeEnd = 575159, XrefRangeStart = 575150, XrefRangeEnd = 575157, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void UpdateLockTargets()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_UpdateLockTargets_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006506 RID: 25862 RVA: 0x00199FB0 File Offset: 0x001981B0
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 575159, RefRangeEnd = 575161, XrefRangeStart = 575159, XrefRangeEnd = 575159, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe Transform GetLockTarget()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_GetLockTarget_Public_Transform_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		IntPtr intPtr3 = intPtr;
		return (intPtr3 != 0) ? new Transform(intPtr3) : null;
	}

	// Token: 0x06006507 RID: 25863 RVA: 0x0019A008 File Offset: 0x00198208
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 575164, RefRangeEnd = 575165, XrefRangeStart = 575161, XrefRangeEnd = 575164, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void DecreaseAbsorbTimers()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_DecreaseAbsorbTimers_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006508 RID: 25864 RVA: 0x0019A04C File Offset: 0x0019824C
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 575165, RefRangeEnd = 575167, XrefRangeStart = 575165, XrefRangeEnd = 575165, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void ResetAbsorbTimers()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_ResetAbsorbTimers_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006509 RID: 25865 RVA: 0x0019A090 File Offset: 0x00198290
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 575167, RefRangeEnd = 575168, XrefRangeStart = 575167, XrefRangeEnd = 575167, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void ResetAbsorbStatusTimer()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_ResetAbsorbStatusTimer_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600650A RID: 25866 RVA: 0x0019A0D4 File Offset: 0x001982D4
	[CallerCount(0)]
	public unsafe void FillAbsorbTimer()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_FillAbsorbTimer_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600650B RID: 25867 RVA: 0x0019A118 File Offset: 0x00198318
	[CallerCount(0)]
	public unsafe void FillAbsorbCDTimer()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_FillAbsorbCDTimer_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600650C RID: 25868 RVA: 0x0019A15C File Offset: 0x0019835C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 575168, RefRangeEnd = 575169, XrefRangeStart = 575168, XrefRangeEnd = 575168, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void FillAbsorbStatusTimer()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_FillAbsorbStatusTimer_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600650D RID: 25869 RVA: 0x0019A1A0 File Offset: 0x001983A0
	[CallerCount(0)]
	public unsafe void UpdateSlipFlag(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(NobetaRuntimeData.NativeMethodInfoPtr_UpdateSlipFlag_Public_Void_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x0600650E RID: 25870 RVA: 0x0019A1F4 File Offset: 0x001983F4
	[CallerCount(0)]
	public unsafe void UpdateChargeEnabled(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(NobetaRuntimeData.NativeMethodInfoPtr_UpdateChargeEnabled_Public_Void_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x0600650F RID: 25871 RVA: 0x0019A248 File Offset: 0x00198448
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 575169, RefRangeEnd = 575170, XrefRangeStart = 575169, XrefRangeEnd = 575169, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void ReverseChargeEnabled()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_ReverseChargeEnabled_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006510 RID: 25872 RVA: 0x0019A28C File Offset: 0x0019848C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 575171, RefRangeEnd = 575172, XrefRangeStart = 575170, XrefRangeEnd = 575171, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void DecreaseDodgeTimer()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_DecreaseDodgeTimer_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006511 RID: 25873 RVA: 0x0019A2D0 File Offset: 0x001984D0
	[CallerCount(0)]
	public unsafe void UpdateDodgeTimer(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(NobetaRuntimeData.NativeMethodInfoPtr_UpdateDodgeTimer_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06006512 RID: 25874 RVA: 0x0019A324 File Offset: 0x00198524
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 575177, RefRangeEnd = 575178, XrefRangeStart = 575172, XrefRangeEnd = 575177, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void DecreaseDamageDodgeTimer()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_DecreaseDamageDodgeTimer_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006513 RID: 25875 RVA: 0x0019A368 File Offset: 0x00198568
	[CallerCount(0)]
	public unsafe void UpdateDamageDodgeTimer(float value = 0.099f)
	{
		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(NobetaRuntimeData.NativeMethodInfoPtr_UpdateDamageDodgeTimer_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06006514 RID: 25876 RVA: 0x0019A3BC File Offset: 0x001985BC
	[CallerCount(0)]
	public unsafe void UpdateShotEffect(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(NobetaRuntimeData.NativeMethodInfoPtr_UpdateShotEffect_Public_Void_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06006515 RID: 25877 RVA: 0x0019A410 File Offset: 0x00198610
	[CallerCount(0)]
	public unsafe void UpdateHardBody(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(NobetaRuntimeData.NativeMethodInfoPtr_UpdateHardBody_Public_Void_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06006516 RID: 25878 RVA: 0x0019A464 File Offset: 0x00198664
	[CallerCount(0)]
	public unsafe void UpdateDodgeDamage(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(NobetaRuntimeData.NativeMethodInfoPtr_UpdateDodgeDamage_Public_Void_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06006517 RID: 25879 RVA: 0x0019A4B8 File Offset: 0x001986B8
	[CallerCount(3)]
	[CachedScanResults(RefRangeStart = 575178, RefRangeEnd = 575181, XrefRangeStart = 575178, XrefRangeEnd = 575178, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void FillPrayerAttackTimer()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_FillPrayerAttackTimer_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006518 RID: 25880 RVA: 0x0019A4FC File Offset: 0x001986FC
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 575182, RefRangeEnd = 575183, XrefRangeStart = 575181, XrefRangeEnd = 575182, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void DecreasePrayerAttackTimer()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_DecreasePrayerAttackTimer_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006519 RID: 25881 RVA: 0x0019A540 File Offset: 0x00198740
	[CallerCount(0)]
	public unsafe void UpdateNextAttack(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(NobetaRuntimeData.NativeMethodInfoPtr_UpdateNextAttack_Public_Void_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x0600651A RID: 25882 RVA: 0x0019A594 File Offset: 0x00198794
	[CallerCount(0)]
	public unsafe void UpdateNextAirAttack(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(NobetaRuntimeData.NativeMethodInfoPtr_UpdateNextAirAttack_Public_Void_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x0600651B RID: 25883 RVA: 0x0019A5E8 File Offset: 0x001987E8
	[CallerCount(0)]
	public unsafe void UpdateAirAttackTimer(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(NobetaRuntimeData.NativeMethodInfoPtr_UpdateAirAttackTimer_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x0600651C RID: 25884 RVA: 0x0019A63C File Offset: 0x0019883C
	[CallerCount(0)]
	public unsafe void IncreaseAirAttackTimer(float delta)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref delta;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_IncreaseAirAttackTimer_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x0600651D RID: 25885 RVA: 0x0019A690 File Offset: 0x00198890
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 575184, RefRangeEnd = 575185, XrefRangeStart = 575183, XrefRangeEnd = 575184, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void DecreaseAirAttackTimer()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_DecreaseAirAttackTimer_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x0600651E RID: 25886 RVA: 0x0019A6D4 File Offset: 0x001988D4
	[CallerCount(0)]
	public unsafe void UpdateWaitTime(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(NobetaRuntimeData.NativeMethodInfoPtr_UpdateWaitTime_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x0600651F RID: 25887 RVA: 0x0019A728 File Offset: 0x00198928
	[CallerCount(22)]
	[CachedScanResults(RefRangeStart = 575186, RefRangeEnd = 575208, XrefRangeStart = 575185, XrefRangeEnd = 575186, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void DecreaseWaitTime()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_DecreaseWaitTime_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006520 RID: 25888 RVA: 0x0019A76C File Offset: 0x0019896C
	[CallerCount(0)]
	public unsafe void UpdateNoFireWaitTime(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(NobetaRuntimeData.NativeMethodInfoPtr_UpdateNoFireWaitTime_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06006521 RID: 25889 RVA: 0x0019A7C0 File Offset: 0x001989C0
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 575209, RefRangeEnd = 575211, XrefRangeStart = 575208, XrefRangeEnd = 575209, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void DecreaseNoFireWaitTime()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_DecreaseNoFireWaitTime_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006522 RID: 25890 RVA: 0x0019A804 File Offset: 0x00198A04
	[CallerCount(0)]
	public unsafe void UpdateAimTime(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(NobetaRuntimeData.NativeMethodInfoPtr_UpdateAimTime_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06006523 RID: 25891 RVA: 0x0019A858 File Offset: 0x00198A58
	[CallerCount(0)]
	public unsafe void UpdateShotTime(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(NobetaRuntimeData.NativeMethodInfoPtr_UpdateShotTime_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06006524 RID: 25892 RVA: 0x0019A8AC File Offset: 0x00198AAC
	[CallerCount(0)]
	public unsafe void UpdateNextTime(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(NobetaRuntimeData.NativeMethodInfoPtr_UpdateNextTime_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06006525 RID: 25893 RVA: 0x0019A900 File Offset: 0x00198B00
	[CallerCount(0)]
	public unsafe void UpdateNextEndTime(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(NobetaRuntimeData.NativeMethodInfoPtr_UpdateNextEndTime_Public_Void_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x06006526 RID: 25894 RVA: 0x0019A954 File Offset: 0x00198B54
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 575126, RefRangeEnd = 575130, XrefRangeStart = 575126, XrefRangeEnd = 575130, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void ResetAllCharacterValue()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_ResetAllCharacterValue_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006527 RID: 25895 RVA: 0x0019A998 File Offset: 0x00198B98
	[CallerCount(0)]
	public unsafe bool CalculateRepulseTimer(float delta)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref delta;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_CalculateRepulseTimer_Public_Boolean_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
	}

	// Token: 0x06006528 RID: 25896 RVA: 0x0019A9FC File Offset: 0x00198BFC
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 575211, XrefRangeEnd = 575213, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe NobetaRuntimeData()
		: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr))
	{
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06006529 RID: 25897 RVA: 0x0019AA48 File Offset: 0x00198C48
	// Note: this type is marked as 'beforefieldinit'.
	static NobetaRuntimeData()
	{
		Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr = IL2CPP.GetIl2CppClass("Assembly-CSharp.dll", "", "NobetaRuntimeData");
		IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr);
		NobetaRuntimeData.NativeFieldInfoPtr_controllable = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "controllable");
		NobetaRuntimeData.NativeFieldInfoPtr_isDead = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "isDead");
		NobetaRuntimeData.NativeFieldInfoPtr_timeScale = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "timeScale");
		NobetaRuntimeData.NativeFieldInfoPtr_deltaTime = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "deltaTime");
		NobetaRuntimeData.NativeFieldInfoPtr_moveSpeed = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "moveSpeed");
		NobetaRuntimeData.NativeFieldInfoPtr_jumpMoveSpeed = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "jumpMoveSpeed");
		NobetaRuntimeData.NativeFieldInfoPtr_moveDirection = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "moveDirection");
		NobetaRuntimeData.NativeFieldInfoPtr_jumpDirection = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "jumpDirection");
		NobetaRuntimeData.NativeFieldInfoPtr_isPond = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "isPond");
		NobetaRuntimeData.NativeFieldInfoPtr_pondHeight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "pondHeight");
		NobetaRuntimeData.NativeFieldInfoPtr_isSky = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "isSky");
		NobetaRuntimeData.NativeFieldInfoPtr_damagedAirStayTimer = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "damagedAirStayTimer");
		NobetaRuntimeData.NativeFieldInfoPtr_fallTimer = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "fallTimer");
		NobetaRuntimeData.NativeFieldInfoPtr_previousPosition = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "previousPosition");
		NobetaRuntimeData.NativeFieldInfoPtr_aimWight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "aimWight");
		NobetaRuntimeData.NativeFieldInfoPtr_aimReadyWight = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "aimReadyWight");
		NobetaRuntimeData.NativeFieldInfoPtr_holdingShot = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "holdingShot");
		NobetaRuntimeData.NativeFieldInfoPtr_hpRecovery = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "hpRecovery");
		NobetaRuntimeData.NativeFieldInfoPtr_mpRecovery = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "mpRecovery");
		NobetaRuntimeData.NativeFieldInfoPtr_mpRecoveryExternal = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "mpRecoveryExternal");
		NobetaRuntimeData.NativeFieldInfoPtr_magicLockTargets = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "magicLockTargets");
		NobetaRuntimeData.NativeFieldInfoPtr_absorbTimer = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "absorbTimer");
		NobetaRuntimeData.NativeFieldInfoPtr_absorbCDTimer = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "absorbCDTimer");
		NobetaRuntimeData.NativeFieldInfoPtr_absorbStatusTimer = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "absorbStatusTimer");
		NobetaRuntimeData.NativeFieldInfoPtr_isSlip = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "isSlip");
		NobetaRuntimeData.NativeFieldInfoPtr_isChargeEnable = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "isChargeEnable");
		NobetaRuntimeData.NativeFieldInfoPtr_dodgeTimer = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "dodgeTimer");
		NobetaRuntimeData.NativeFieldInfoPtr_damageDodgeTimer = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "damageDodgeTimer");
		NobetaRuntimeData.NativeFieldInfoPtr_repulseTimer = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "repulseTimer");
		NobetaRuntimeData.NativeFieldInfoPtr_shotEffect = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "shotEffect");
		NobetaRuntimeData.NativeFieldInfoPtr_hardBody = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "hardBody");
		NobetaRuntimeData.NativeFieldInfoPtr_dodgeDamage = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "dodgeDamage");
		NobetaRuntimeData.NativeFieldInfoPtr_prayerAttackTimer = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "prayerAttackTimer");
		NobetaRuntimeData.NativeFieldInfoPtr_nextAttack = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "nextAttack");
		NobetaRuntimeData.NativeFieldInfoPtr_nextAirAttack = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "nextAirAttack");
		NobetaRuntimeData.NativeFieldInfoPtr_airAttackTimer = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "airAttackTimer");
		NobetaRuntimeData.NativeFieldInfoPtr_waitTime = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "waitTime");
		NobetaRuntimeData.NativeFieldInfoPtr_noFireWaitTime = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "noFireWaitTime");
		NobetaRuntimeData.NativeFieldInfoPtr_aimTime = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "aimTime");
		NobetaRuntimeData.NativeFieldInfoPtr_shotTime = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "shotTime");
		NobetaRuntimeData.NativeFieldInfoPtr_nextTime = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "nextTime");
		NobetaRuntimeData.NativeFieldInfoPtr_nextEndTime = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "nextEndTime");
		NobetaRuntimeData.NativeFieldInfoPtr_ABSORB_TIME_MAX = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "ABSORB_TIME_MAX");
		NobetaRuntimeData.NativeFieldInfoPtr_ABSORB_STATUS_TIME_MAX = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "ABSORB_STATUS_TIME_MAX");
		NobetaRuntimeData.NativeFieldInfoPtr_ABSORB_CD_TIME_MAX = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "ABSORB_CD_TIME_MAX");
		NobetaRuntimeData.NativeFieldInfoPtr_FULL_TIMER_LIMIT = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "FULL_TIMER_LIMIT");
		NobetaRuntimeData.NativeFieldInfoPtr_REPULSE_TIME_MAX = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "REPULSE_TIME_MAX");
		NobetaRuntimeData.NativeFieldInfoPtr_PRAYER_ATTACK_TIME_MAX = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, "PRAYER_ATTACK_TIME_MAX");
		NobetaRuntimeData.NativeMethodInfoPtr_get_Controllable_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670709);
		NobetaRuntimeData.NativeMethodInfoPtr_get_IsDead_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670710);
		NobetaRuntimeData.NativeMethodInfoPtr_get_DeltaTime_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670711);
		NobetaRuntimeData.NativeMethodInfoPtr_get_TimeScale_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670712);
		NobetaRuntimeData.NativeMethodInfoPtr_get_MoveSpeed_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670713);
		NobetaRuntimeData.NativeMethodInfoPtr_get_JumpMoveSpeed_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670714);
		NobetaRuntimeData.NativeMethodInfoPtr_get_RotationSpeed_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670715);
		NobetaRuntimeData.NativeMethodInfoPtr_get_MoveSpeedScale_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670716);
		NobetaRuntimeData.NativeMethodInfoPtr_get_MoveDirection_Public_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670717);
		NobetaRuntimeData.NativeMethodInfoPtr_get_JumpDirection_Public_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670718);
		NobetaRuntimeData.NativeMethodInfoPtr_get_JumpForce_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670719);
		NobetaRuntimeData.NativeMethodInfoPtr_get_Gravity_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670720);
		NobetaRuntimeData.NativeMethodInfoPtr_get_IsPond_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670721);
		NobetaRuntimeData.NativeMethodInfoPtr_get_PondHeight_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670722);
		NobetaRuntimeData.NativeMethodInfoPtr_get_IsSky_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670723);
		NobetaRuntimeData.NativeMethodInfoPtr_get_FallSpeedMax_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670724);
		NobetaRuntimeData.NativeMethodInfoPtr_get_FallTimer_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670725);
		NobetaRuntimeData.NativeMethodInfoPtr_get_AimReadyWight_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670726);
		NobetaRuntimeData.NativeMethodInfoPtr_get_AimWight_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670727);
		NobetaRuntimeData.NativeMethodInfoPtr_get_HoldingShot_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670728);
		NobetaRuntimeData.NativeMethodInfoPtr_set_HoldingShot_Public_set_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670729);
		NobetaRuntimeData.NativeMethodInfoPtr_get_HPRecovery_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670730);
		NobetaRuntimeData.NativeMethodInfoPtr_get_MPRecovery_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670731);
		NobetaRuntimeData.NativeMethodInfoPtr_get_MPRecoveryExternal_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670732);
		NobetaRuntimeData.NativeMethodInfoPtr_get_MagicLockTargets_Public_get_Il2CppReferenceArray_1_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670733);
		NobetaRuntimeData.NativeMethodInfoPtr_get_HasMagicLockTargets_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670734);
		NobetaRuntimeData.NativeMethodInfoPtr_get_StaminaLossDodge_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670735);
		NobetaRuntimeData.NativeMethodInfoPtr_get_StaminaLossDash_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670736);
		NobetaRuntimeData.NativeMethodInfoPtr_get_StaminaLossFall_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670737);
		NobetaRuntimeData.NativeMethodInfoPtr_get_StaminaLossJump_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670738);
		NobetaRuntimeData.NativeMethodInfoPtr_get_AbsorbTimer_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670739);
		NobetaRuntimeData.NativeMethodInfoPtr_get_AbsorbCDTimer_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670740);
		NobetaRuntimeData.NativeMethodInfoPtr_get_AbsorbStatusTimer_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670741);
		NobetaRuntimeData.NativeMethodInfoPtr_get_IsSlip_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670742);
		NobetaRuntimeData.NativeMethodInfoPtr_get_IsChargeEnable_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670743);
		NobetaRuntimeData.NativeMethodInfoPtr_get_DodgeTimer_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670744);
		NobetaRuntimeData.NativeMethodInfoPtr_get_DamageDodgeTimer_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670745);
		NobetaRuntimeData.NativeMethodInfoPtr_get_ShotEffect_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670746);
		NobetaRuntimeData.NativeMethodInfoPtr_get_HardBody_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670747);
		NobetaRuntimeData.NativeMethodInfoPtr_get_DodgeDamage_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670748);
		NobetaRuntimeData.NativeMethodInfoPtr_get_PrayerAttackTimer_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670749);
		NobetaRuntimeData.NativeMethodInfoPtr_get_NextAttack_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670750);
		NobetaRuntimeData.NativeMethodInfoPtr_get_NextAirAttack_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670751);
		NobetaRuntimeData.NativeMethodInfoPtr_get_AirAttackTimer_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670752);
		NobetaRuntimeData.NativeMethodInfoPtr_get_WaitTime_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670753);
		NobetaRuntimeData.NativeMethodInfoPtr_get_NoFireWaitTime_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670754);
		NobetaRuntimeData.NativeMethodInfoPtr_get_AimTime_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670755);
		NobetaRuntimeData.NativeMethodInfoPtr_get_ShotTime_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670756);
		NobetaRuntimeData.NativeMethodInfoPtr_get_NextTime_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670757);
		NobetaRuntimeData.NativeMethodInfoPtr_get_NextEndTime_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670758);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateControllable_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670759);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateIsDead_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670760);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateTimeMembers_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670761);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateMoveSpeed_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670762);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateMoveDirection_Public_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670763);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateJumpDirection_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670764);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateJumpDirection_Public_Void_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670765);
		NobetaRuntimeData.NativeMethodInfoPtr_IncreaseDamagedAirStayTimer_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670766);
		NobetaRuntimeData.NativeMethodInfoPtr_ResetDamagedAirStayTimer_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670767);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateJumpMoveSpeed_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670768);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateIsPond_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670769);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdatePondHeight_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670770);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateIsSky_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670771);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateFallTimer_Public_Void_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670772);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateAimReadyWight_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670773);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateAimWight_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670774);
		NobetaRuntimeData.NativeMethodInfoPtr_ResetAimWightValues_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670775);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateHPRecovery_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670776);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateMPRecovery_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670777);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateMPRecoveryExternal_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670778);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateLockTargets_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670779);
		NobetaRuntimeData.NativeMethodInfoPtr_GetLockTarget_Public_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670780);
		NobetaRuntimeData.NativeMethodInfoPtr_DecreaseAbsorbTimers_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670781);
		NobetaRuntimeData.NativeMethodInfoPtr_ResetAbsorbTimers_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670782);
		NobetaRuntimeData.NativeMethodInfoPtr_ResetAbsorbStatusTimer_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670783);
		NobetaRuntimeData.NativeMethodInfoPtr_FillAbsorbTimer_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670784);
		NobetaRuntimeData.NativeMethodInfoPtr_FillAbsorbCDTimer_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670785);
		NobetaRuntimeData.NativeMethodInfoPtr_FillAbsorbStatusTimer_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670786);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateSlipFlag_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670787);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateChargeEnabled_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670788);
		NobetaRuntimeData.NativeMethodInfoPtr_ReverseChargeEnabled_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670789);
		NobetaRuntimeData.NativeMethodInfoPtr_DecreaseDodgeTimer_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670790);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateDodgeTimer_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670791);
		NobetaRuntimeData.NativeMethodInfoPtr_DecreaseDamageDodgeTimer_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670792);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateDamageDodgeTimer_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670793);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateShotEffect_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670794);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateHardBody_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670795);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateDodgeDamage_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670796);
		NobetaRuntimeData.NativeMethodInfoPtr_FillPrayerAttackTimer_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670797);
		NobetaRuntimeData.NativeMethodInfoPtr_DecreasePrayerAttackTimer_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670798);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateNextAttack_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670799);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateNextAirAttack_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670800);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateAirAttackTimer_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670801);
		NobetaRuntimeData.NativeMethodInfoPtr_IncreaseAirAttackTimer_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670802);
		NobetaRuntimeData.NativeMethodInfoPtr_DecreaseAirAttackTimer_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670803);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateWaitTime_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670804);
		NobetaRuntimeData.NativeMethodInfoPtr_DecreaseWaitTime_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670805);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateNoFireWaitTime_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670806);
		NobetaRuntimeData.NativeMethodInfoPtr_DecreaseNoFireWaitTime_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670807);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateAimTime_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670808);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateShotTime_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670809);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateNextTime_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670810);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateNextEndTime_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670811);
		NobetaRuntimeData.NativeMethodInfoPtr_ResetAllCharacterValue_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670812);
		NobetaRuntimeData.NativeMethodInfoPtr_CalculateRepulseTimer_Public_Boolean_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670813);
		NobetaRuntimeData.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670814);
	}

	// Token: 0x0600652A RID: 25898 RVA: 0x0000A688 File Offset: 0x00008888
	public NobetaRuntimeData(IntPtr pointer)
		: base(pointer)
	{
	}

	// Token: 0x170022B1 RID: 8881
	// (get) Token: 0x0600652B RID: 25899 RVA: 0x0019B680 File Offset: 0x00199880
	// (set) Token: 0x0600652C RID: 25900 RVA: 0x0019B6A8 File Offset: 0x001998A8
	public unsafe bool controllable
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_controllable);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_controllable)) = value;
		}
	}

	// Token: 0x170022B2 RID: 8882
	// (get) Token: 0x0600652D RID: 25901 RVA: 0x0019B6CC File Offset: 0x001998CC
	// (set) Token: 0x0600652E RID: 25902 RVA: 0x0019B6F4 File Offset: 0x001998F4
	public unsafe bool isDead
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_isDead);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_isDead)) = value;
		}
	}

	// Token: 0x170022B3 RID: 8883
	// (get) Token: 0x0600652F RID: 25903 RVA: 0x0019B718 File Offset: 0x00199918
	// (set) Token: 0x06006530 RID: 25904 RVA: 0x0019B740 File Offset: 0x00199940
	public unsafe float timeScale
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_timeScale);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_timeScale)) = value;
		}
	}

	// Token: 0x170022B4 RID: 8884
	// (get) Token: 0x06006531 RID: 25905 RVA: 0x0019B764 File Offset: 0x00199964
	// (set) Token: 0x06006532 RID: 25906 RVA: 0x0019B78C File Offset: 0x0019998C
	public unsafe float deltaTime
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_deltaTime);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_deltaTime)) = value;
		}
	}

	// Token: 0x170022B5 RID: 8885
	// (get) Token: 0x06006533 RID: 25907 RVA: 0x0019B7B0 File Offset: 0x001999B0
	// (set) Token: 0x06006534 RID: 25908 RVA: 0x0019B7D8 File Offset: 0x001999D8
	public unsafe float moveSpeed
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_moveSpeed);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_moveSpeed)) = value;
		}
	}

	// Token: 0x170022B6 RID: 8886
	// (get) Token: 0x06006535 RID: 25909 RVA: 0x0019B7FC File Offset: 0x001999FC
	// (set) Token: 0x06006536 RID: 25910 RVA: 0x0019B824 File Offset: 0x00199A24
	public unsafe float jumpMoveSpeed
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_jumpMoveSpeed);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_jumpMoveSpeed)) = value;
		}
	}

	// Token: 0x170022B7 RID: 8887
	// (get) Token: 0x06006537 RID: 25911 RVA: 0x0019B848 File Offset: 0x00199A48
	// (set) Token: 0x06006538 RID: 25912 RVA: 0x0019B870 File Offset: 0x00199A70
	public unsafe Vector3 moveDirection
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_moveDirection);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_moveDirection)) = value;
		}
	}

	// Token: 0x170022B8 RID: 8888
	// (get) Token: 0x06006539 RID: 25913 RVA: 0x0019B894 File Offset: 0x00199A94
	// (set) Token: 0x0600653A RID: 25914 RVA: 0x0019B8BC File Offset: 0x00199ABC
	public unsafe Vector3 jumpDirection
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_jumpDirection);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_jumpDirection)) = value;
		}
	}

	// Token: 0x170022B9 RID: 8889
	// (get) Token: 0x0600653B RID: 25915 RVA: 0x0019B8E0 File Offset: 0x00199AE0
	// (set) Token: 0x0600653C RID: 25916 RVA: 0x0019B908 File Offset: 0x00199B08
	public unsafe bool isPond
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_isPond);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_isPond)) = value;
		}
	}

	// Token: 0x170022BA RID: 8890
	// (get) Token: 0x0600653D RID: 25917 RVA: 0x0019B92C File Offset: 0x00199B2C
	// (set) Token: 0x0600653E RID: 25918 RVA: 0x0019B954 File Offset: 0x00199B54
	public unsafe float pondHeight
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_pondHeight);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_pondHeight)) = value;
		}
	}

	// Token: 0x170022BB RID: 8891
	// (get) Token: 0x0600653F RID: 25919 RVA: 0x0019B978 File Offset: 0x00199B78
	// (set) Token: 0x06006540 RID: 25920 RVA: 0x0019B9A0 File Offset: 0x00199BA0
	public unsafe bool isSky
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_isSky);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_isSky)) = value;
		}
	}

	// Token: 0x170022BC RID: 8892
	// (get) Token: 0x06006541 RID: 25921 RVA: 0x0019B9C4 File Offset: 0x00199BC4
	// (set) Token: 0x06006542 RID: 25922 RVA: 0x0019B9EC File Offset: 0x00199BEC
	public unsafe float damagedAirStayTimer
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_damagedAirStayTimer);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_damagedAirStayTimer)) = value;
		}
	}

	// Token: 0x170022BD RID: 8893
	// (get) Token: 0x06006543 RID: 25923 RVA: 0x0019BA10 File Offset: 0x00199C10
	// (set) Token: 0x06006544 RID: 25924 RVA: 0x0019BA38 File Offset: 0x00199C38
	public unsafe float fallTimer
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_fallTimer);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_fallTimer)) = value;
		}
	}

	// Token: 0x170022BE RID: 8894
	// (get) Token: 0x06006545 RID: 25925 RVA: 0x0019BA5C File Offset: 0x00199C5C
	// (set) Token: 0x06006546 RID: 25926 RVA: 0x0019BA84 File Offset: 0x00199C84
	public unsafe Vector3 previousPosition
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_previousPosition);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_previousPosition)) = value;
		}
	}

	// Token: 0x170022BF RID: 8895
	// (get) Token: 0x06006547 RID: 25927 RVA: 0x0019BAA8 File Offset: 0x00199CA8
	// (set) Token: 0x06006548 RID: 25928 RVA: 0x0019BAD0 File Offset: 0x00199CD0
	public unsafe float aimWight
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_aimWight);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_aimWight)) = value;
		}
	}

	// Token: 0x170022C0 RID: 8896
	// (get) Token: 0x06006549 RID: 25929 RVA: 0x0019BAF4 File Offset: 0x00199CF4
	// (set) Token: 0x0600654A RID: 25930 RVA: 0x0019BB1C File Offset: 0x00199D1C
	public unsafe float aimReadyWight
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_aimReadyWight);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_aimReadyWight)) = value;
		}
	}

	// Token: 0x170022C1 RID: 8897
	// (get) Token: 0x0600654B RID: 25931 RVA: 0x0019BB40 File Offset: 0x00199D40
	// (set) Token: 0x0600654C RID: 25932 RVA: 0x0019BB68 File Offset: 0x00199D68
	public unsafe float holdingShot
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_holdingShot);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_holdingShot)) = value;
		}
	}

	// Token: 0x170022C2 RID: 8898
	// (get) Token: 0x0600654D RID: 25933 RVA: 0x0019BB8C File Offset: 0x00199D8C
	// (set) Token: 0x0600654E RID: 25934 RVA: 0x0019BBB4 File Offset: 0x00199DB4
	public unsafe float hpRecovery
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_hpRecovery);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_hpRecovery)) = value;
		}
	}

	// Token: 0x170022C3 RID: 8899
	// (get) Token: 0x0600654F RID: 25935 RVA: 0x0019BBD8 File Offset: 0x00199DD8
	// (set) Token: 0x06006550 RID: 25936 RVA: 0x0019BC00 File Offset: 0x00199E00
	public unsafe float mpRecovery
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_mpRecovery);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_mpRecovery)) = value;
		}
	}

	// Token: 0x170022C4 RID: 8900
	// (get) Token: 0x06006551 RID: 25937 RVA: 0x0019BC24 File Offset: 0x00199E24
	// (set) Token: 0x06006552 RID: 25938 RVA: 0x0019BC4C File Offset: 0x00199E4C
	public unsafe float mpRecoveryExternal
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_mpRecoveryExternal);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_mpRecoveryExternal)) = value;
		}
	}

	// Token: 0x170022C5 RID: 8901
	// (get) Token: 0x06006553 RID: 25939 RVA: 0x0019BC70 File Offset: 0x00199E70
	// (set) Token: 0x06006554 RID: 25940 RVA: 0x0019BCA4 File Offset: 0x00199EA4
	public unsafe Il2CppReferenceArray<Transform> magicLockTargets
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_magicLockTargets);
			IntPtr intPtr2 = *intPtr;
			return (intPtr2 != 0) ? new Il2CppReferenceArray<Transform>(intPtr2) : null;
		}
		set
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_magicLockTargets), IL2CPP.Il2CppObjectBaseToPtr(value));
		}
	}

	// Token: 0x170022C6 RID: 8902
	// (get) Token: 0x06006555 RID: 25941 RVA: 0x0019BCCC File Offset: 0x00199ECC
	// (set) Token: 0x06006556 RID: 25942 RVA: 0x0019BCF4 File Offset: 0x00199EF4
	public unsafe float absorbTimer
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_absorbTimer);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_absorbTimer)) = value;
		}
	}

	// Token: 0x170022C7 RID: 8903
	// (get) Token: 0x06006557 RID: 25943 RVA: 0x0019BD18 File Offset: 0x00199F18
	// (set) Token: 0x06006558 RID: 25944 RVA: 0x0019BD40 File Offset: 0x00199F40
	public unsafe float absorbCDTimer
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_absorbCDTimer);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_absorbCDTimer)) = value;
		}
	}

	// Token: 0x170022C8 RID: 8904
	// (get) Token: 0x06006559 RID: 25945 RVA: 0x0019BD64 File Offset: 0x00199F64
	// (set) Token: 0x0600655A RID: 25946 RVA: 0x0019BD8C File Offset: 0x00199F8C
	public unsafe float absorbStatusTimer
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_absorbStatusTimer);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_absorbStatusTimer)) = value;
		}
	}

	// Token: 0x170022C9 RID: 8905
	// (get) Token: 0x0600655B RID: 25947 RVA: 0x0019BDB0 File Offset: 0x00199FB0
	// (set) Token: 0x0600655C RID: 25948 RVA: 0x0019BDD8 File Offset: 0x00199FD8
	public unsafe bool isSlip
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_isSlip);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_isSlip)) = value;
		}
	}

	// Token: 0x170022CA RID: 8906
	// (get) Token: 0x0600655D RID: 25949 RVA: 0x0019BDFC File Offset: 0x00199FFC
	// (set) Token: 0x0600655E RID: 25950 RVA: 0x0019BE24 File Offset: 0x0019A024
	public unsafe bool isChargeEnable
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_isChargeEnable);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_isChargeEnable)) = value;
		}
	}

	// Token: 0x170022CB RID: 8907
	// (get) Token: 0x0600655F RID: 25951 RVA: 0x0019BE48 File Offset: 0x0019A048
	// (set) Token: 0x06006560 RID: 25952 RVA: 0x0019BE70 File Offset: 0x0019A070
	public unsafe float dodgeTimer
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_dodgeTimer);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_dodgeTimer)) = value;
		}
	}

	// Token: 0x170022CC RID: 8908
	// (get) Token: 0x06006561 RID: 25953 RVA: 0x0019BE94 File Offset: 0x0019A094
	// (set) Token: 0x06006562 RID: 25954 RVA: 0x0019BEBC File Offset: 0x0019A0BC
	public unsafe float damageDodgeTimer
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_damageDodgeTimer);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_damageDodgeTimer)) = value;
		}
	}

	// Token: 0x170022CD RID: 8909
	// (get) Token: 0x06006563 RID: 25955 RVA: 0x0019BEE0 File Offset: 0x0019A0E0
	// (set) Token: 0x06006564 RID: 25956 RVA: 0x0019BF08 File Offset: 0x0019A108
	public unsafe float repulseTimer
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_repulseTimer);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_repulseTimer)) = value;
		}
	}

	// Token: 0x170022CE RID: 8910
	// (get) Token: 0x06006565 RID: 25957 RVA: 0x0019BF2C File Offset: 0x0019A12C
	// (set) Token: 0x06006566 RID: 25958 RVA: 0x0019BF54 File Offset: 0x0019A154
	public unsafe bool shotEffect
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_shotEffect);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_shotEffect)) = value;
		}
	}

	// Token: 0x170022CF RID: 8911
	// (get) Token: 0x06006567 RID: 25959 RVA: 0x0019BF78 File Offset: 0x0019A178
	// (set) Token: 0x06006568 RID: 25960 RVA: 0x0019BFA0 File Offset: 0x0019A1A0
	public unsafe bool hardBody
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_hardBody);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_hardBody)) = value;
		}
	}

	// Token: 0x170022D0 RID: 8912
	// (get) Token: 0x06006569 RID: 25961 RVA: 0x0019BFC4 File Offset: 0x0019A1C4
	// (set) Token: 0x0600656A RID: 25962 RVA: 0x0019BFEC File Offset: 0x0019A1EC
	public unsafe bool dodgeDamage
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_dodgeDamage);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_dodgeDamage)) = value;
		}
	}

	// Token: 0x170022D1 RID: 8913
	// (get) Token: 0x0600656B RID: 25963 RVA: 0x0019C010 File Offset: 0x0019A210
	// (set) Token: 0x0600656C RID: 25964 RVA: 0x0019C038 File Offset: 0x0019A238
	public unsafe float prayerAttackTimer
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_prayerAttackTimer);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_prayerAttackTimer)) = value;
		}
	}

	// Token: 0x170022D2 RID: 8914
	// (get) Token: 0x0600656D RID: 25965 RVA: 0x0019C05C File Offset: 0x0019A25C
	// (set) Token: 0x0600656E RID: 25966 RVA: 0x0019C084 File Offset: 0x0019A284
	public unsafe bool nextAttack
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_nextAttack);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_nextAttack)) = value;
		}
	}

	// Token: 0x170022D3 RID: 8915
	// (get) Token: 0x0600656F RID: 25967 RVA: 0x0019C0A8 File Offset: 0x0019A2A8
	// (set) Token: 0x06006570 RID: 25968 RVA: 0x0019C0D0 File Offset: 0x0019A2D0
	public unsafe bool nextAirAttack
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_nextAirAttack);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_nextAirAttack)) = value;
		}
	}

	// Token: 0x170022D4 RID: 8916
	// (get) Token: 0x06006571 RID: 25969 RVA: 0x0019C0F4 File Offset: 0x0019A2F4
	// (set) Token: 0x06006572 RID: 25970 RVA: 0x0019C11C File Offset: 0x0019A31C
	public unsafe float airAttackTimer
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_airAttackTimer);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_airAttackTimer)) = value;
		}
	}

	// Token: 0x170022D5 RID: 8917
	// (get) Token: 0x06006573 RID: 25971 RVA: 0x0019C140 File Offset: 0x0019A340
	// (set) Token: 0x06006574 RID: 25972 RVA: 0x0019C168 File Offset: 0x0019A368
	public unsafe float waitTime
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_waitTime);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_waitTime)) = value;
		}
	}

	// Token: 0x170022D6 RID: 8918
	// (get) Token: 0x06006575 RID: 25973 RVA: 0x0019C18C File Offset: 0x0019A38C
	// (set) Token: 0x06006576 RID: 25974 RVA: 0x0019C1B4 File Offset: 0x0019A3B4
	public unsafe float noFireWaitTime
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_noFireWaitTime);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_noFireWaitTime)) = value;
		}
	}

	// Token: 0x170022D7 RID: 8919
	// (get) Token: 0x06006577 RID: 25975 RVA: 0x0019C1D8 File Offset: 0x0019A3D8
	// (set) Token: 0x06006578 RID: 25976 RVA: 0x0019C200 File Offset: 0x0019A400
	public unsafe float aimTime
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_aimTime);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_aimTime)) = value;
		}
	}

	// Token: 0x170022D8 RID: 8920
	// (get) Token: 0x06006579 RID: 25977 RVA: 0x0019C224 File Offset: 0x0019A424
	// (set) Token: 0x0600657A RID: 25978 RVA: 0x0019C24C File Offset: 0x0019A44C
	public unsafe float shotTime
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_shotTime);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_shotTime)) = value;
		}
	}

	// Token: 0x170022D9 RID: 8921
	// (get) Token: 0x0600657B RID: 25979 RVA: 0x0019C270 File Offset: 0x0019A470
	// (set) Token: 0x0600657C RID: 25980 RVA: 0x0019C298 File Offset: 0x0019A498
	public unsafe float nextTime
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_nextTime);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_nextTime)) = value;
		}
	}

	// Token: 0x170022DA RID: 8922
	// (get) Token: 0x0600657D RID: 25981 RVA: 0x0019C2BC File Offset: 0x0019A4BC
	// (set) Token: 0x0600657E RID: 25982 RVA: 0x0019C2E4 File Offset: 0x0019A4E4
	public unsafe float nextEndTime
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_nextEndTime);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(NobetaRuntimeData.NativeFieldInfoPtr_nextEndTime)) = value;
		}
	}

	// Token: 0x170022DB RID: 8923
	// (get) Token: 0x0600657F RID: 25983 RVA: 0x0019C308 File Offset: 0x0019A508
	// (set) Token: 0x06006580 RID: 25984 RVA: 0x0019C326 File Offset: 0x0019A526
	public unsafe static float ABSORB_TIME_MAX
	{
		get
		{
			float num;
			IL2CPP.il2cpp_field_static_get_value(NobetaRuntimeData.NativeFieldInfoPtr_ABSORB_TIME_MAX, (void*)(&num));
			return num;
		}
		set
		{
			IL2CPP.il2cpp_field_static_set_value(NobetaRuntimeData.NativeFieldInfoPtr_ABSORB_TIME_MAX, (void*)(&value));
		}
	}

	// Token: 0x170022DC RID: 8924
	// (get) Token: 0x06006581 RID: 25985 RVA: 0x0019C338 File Offset: 0x0019A538
	// (set) Token: 0x06006582 RID: 25986 RVA: 0x0019C356 File Offset: 0x0019A556
	public unsafe static float ABSORB_STATUS_TIME_MAX
	{
		get
		{
			float num;
			IL2CPP.il2cpp_field_static_get_value(NobetaRuntimeData.NativeFieldInfoPtr_ABSORB_STATUS_TIME_MAX, (void*)(&num));
			return num;
		}
		set
		{
			IL2CPP.il2cpp_field_static_set_value(NobetaRuntimeData.NativeFieldInfoPtr_ABSORB_STATUS_TIME_MAX, (void*)(&value));
		}
	}

	// Token: 0x170022DD RID: 8925
	// (get) Token: 0x06006583 RID: 25987 RVA: 0x0019C368 File Offset: 0x0019A568
	// (set) Token: 0x06006584 RID: 25988 RVA: 0x0019C386 File Offset: 0x0019A586
	public unsafe static float ABSORB_CD_TIME_MAX
	{
		get
		{
			float num;
			IL2CPP.il2cpp_field_static_get_value(NobetaRuntimeData.NativeFieldInfoPtr_ABSORB_CD_TIME_MAX, (void*)(&num));
			return num;
		}
		set
		{
			IL2CPP.il2cpp_field_static_set_value(NobetaRuntimeData.NativeFieldInfoPtr_ABSORB_CD_TIME_MAX, (void*)(&value));
		}
	}

	// Token: 0x170022DE RID: 8926
	// (get) Token: 0x06006585 RID: 25989 RVA: 0x0019C398 File Offset: 0x0019A598
	// (set) Token: 0x06006586 RID: 25990 RVA: 0x0019C3B6 File Offset: 0x0019A5B6
	public unsafe static float FULL_TIMER_LIMIT
	{
		get
		{
			float num;
			IL2CPP.il2cpp_field_static_get_value(NobetaRuntimeData.NativeFieldInfoPtr_FULL_TIMER_LIMIT, (void*)(&num));
			return num;
		}
		set
		{
			IL2CPP.il2cpp_field_static_set_value(NobetaRuntimeData.NativeFieldInfoPtr_FULL_TIMER_LIMIT, (void*)(&value));
		}
	}

	// Token: 0x170022DF RID: 8927
	// (get) Token: 0x06006587 RID: 25991 RVA: 0x0019C3C8 File Offset: 0x0019A5C8
	// (set) Token: 0x06006588 RID: 25992 RVA: 0x0019C3E6 File Offset: 0x0019A5E6
	public unsafe static float REPULSE_TIME_MAX
	{
		get
		{
			float num;
			IL2CPP.il2cpp_field_static_get_value(NobetaRuntimeData.NativeFieldInfoPtr_REPULSE_TIME_MAX, (void*)(&num));
			return num;
		}
		set
		{
			IL2CPP.il2cpp_field_static_set_value(NobetaRuntimeData.NativeFieldInfoPtr_REPULSE_TIME_MAX, (void*)(&value));
		}
	}

	// Token: 0x170022E0 RID: 8928
	// (get) Token: 0x06006589 RID: 25993 RVA: 0x0019C3F8 File Offset: 0x0019A5F8
	// (set) Token: 0x0600658A RID: 25994 RVA: 0x0019C416 File Offset: 0x0019A616
	public unsafe static float PRAYER_ATTACK_TIME_MAX
	{
		get
		{
			float num;
			IL2CPP.il2cpp_field_static_get_value(NobetaRuntimeData.NativeFieldInfoPtr_PRAYER_ATTACK_TIME_MAX, (void*)(&num));
			return num;
		}
		set
		{
			IL2CPP.il2cpp_field_static_set_value(NobetaRuntimeData.NativeFieldInfoPtr_PRAYER_ATTACK_TIME_MAX, (void*)(&value));
		}
	}

	// Token: 0x040042EA RID: 17130
	private static readonly IntPtr NativeFieldInfoPtr_controllable;

	// Token: 0x040042EB RID: 17131
	private static readonly IntPtr NativeFieldInfoPtr_isDead;

	// Token: 0x040042EC RID: 17132
	private static readonly IntPtr NativeFieldInfoPtr_timeScale;

	// Token: 0x040042ED RID: 17133
	private static readonly IntPtr NativeFieldInfoPtr_deltaTime;

	// Token: 0x040042EE RID: 17134
	private static readonly IntPtr NativeFieldInfoPtr_moveSpeed;

	// Token: 0x040042EF RID: 17135
	private static readonly IntPtr NativeFieldInfoPtr_jumpMoveSpeed;

	// Token: 0x040042F0 RID: 17136
	private static readonly IntPtr NativeFieldInfoPtr_moveDirection;

	// Token: 0x040042F1 RID: 17137
	private static readonly IntPtr NativeFieldInfoPtr_jumpDirection;

	// Token: 0x040042F2 RID: 17138
	private static readonly IntPtr NativeFieldInfoPtr_isPond;

	// Token: 0x040042F3 RID: 17139
	private static readonly IntPtr NativeFieldInfoPtr_pondHeight;

	// Token: 0x040042F4 RID: 17140
	private static readonly IntPtr NativeFieldInfoPtr_isSky;

	// Token: 0x040042F5 RID: 17141
	private static readonly IntPtr NativeFieldInfoPtr_damagedAirStayTimer;

	// Token: 0x040042F6 RID: 17142
	private static readonly IntPtr NativeFieldInfoPtr_fallTimer;

	// Token: 0x040042F7 RID: 17143
	private static readonly IntPtr NativeFieldInfoPtr_previousPosition;

	// Token: 0x040042F8 RID: 17144
	private static readonly IntPtr NativeFieldInfoPtr_aimWight;

	// Token: 0x040042F9 RID: 17145
	private static readonly IntPtr NativeFieldInfoPtr_aimReadyWight;

	// Token: 0x040042FA RID: 17146
	private static readonly IntPtr NativeFieldInfoPtr_holdingShot;

	// Token: 0x040042FB RID: 17147
	private static readonly IntPtr NativeFieldInfoPtr_hpRecovery;

	// Token: 0x040042FC RID: 17148
	private static readonly IntPtr NativeFieldInfoPtr_mpRecovery;

	// Token: 0x040042FD RID: 17149
	private static readonly IntPtr NativeFieldInfoPtr_mpRecoveryExternal;

	// Token: 0x040042FE RID: 17150
	private static readonly IntPtr NativeFieldInfoPtr_magicLockTargets;

	// Token: 0x040042FF RID: 17151
	private static readonly IntPtr NativeFieldInfoPtr_absorbTimer;

	// Token: 0x04004300 RID: 17152
	private static readonly IntPtr NativeFieldInfoPtr_absorbCDTimer;

	// Token: 0x04004301 RID: 17153
	private static readonly IntPtr NativeFieldInfoPtr_absorbStatusTimer;

	// Token: 0x04004302 RID: 17154
	private static readonly IntPtr NativeFieldInfoPtr_isSlip;

	// Token: 0x04004303 RID: 17155
	private static readonly IntPtr NativeFieldInfoPtr_isChargeEnable;

	// Token: 0x04004304 RID: 17156
	private static readonly IntPtr NativeFieldInfoPtr_dodgeTimer;

	// Token: 0x04004305 RID: 17157
	private static readonly IntPtr NativeFieldInfoPtr_damageDodgeTimer;

	// Token: 0x04004306 RID: 17158
	private static readonly IntPtr NativeFieldInfoPtr_repulseTimer;

	// Token: 0x04004307 RID: 17159
	private static readonly IntPtr NativeFieldInfoPtr_shotEffect;

	// Token: 0x04004308 RID: 17160
	private static readonly IntPtr NativeFieldInfoPtr_hardBody;

	// Token: 0x04004309 RID: 17161
	private static readonly IntPtr NativeFieldInfoPtr_dodgeDamage;

	// Token: 0x0400430A RID: 17162
	private static readonly IntPtr NativeFieldInfoPtr_prayerAttackTimer;

	// Token: 0x0400430B RID: 17163
	private static readonly IntPtr NativeFieldInfoPtr_nextAttack;

	// Token: 0x0400430C RID: 17164
	private static readonly IntPtr NativeFieldInfoPtr_nextAirAttack;

	// Token: 0x0400430D RID: 17165
	private static readonly IntPtr NativeFieldInfoPtr_airAttackTimer;

	// Token: 0x0400430E RID: 17166
	private static readonly IntPtr NativeFieldInfoPtr_waitTime;

	// Token: 0x0400430F RID: 17167
	private static readonly IntPtr NativeFieldInfoPtr_noFireWaitTime;

	// Token: 0x04004310 RID: 17168
	private static readonly IntPtr NativeFieldInfoPtr_aimTime;

	// Token: 0x04004311 RID: 17169
	private static readonly IntPtr NativeFieldInfoPtr_shotTime;

	// Token: 0x04004312 RID: 17170
	private static readonly IntPtr NativeFieldInfoPtr_nextTime;

	// Token: 0x04004313 RID: 17171
	private static readonly IntPtr NativeFieldInfoPtr_nextEndTime;

	// Token: 0x04004314 RID: 17172
	private static readonly IntPtr NativeFieldInfoPtr_ABSORB_TIME_MAX;

	// Token: 0x04004315 RID: 17173
	private static readonly IntPtr NativeFieldInfoPtr_ABSORB_STATUS_TIME_MAX;

	// Token: 0x04004316 RID: 17174
	private static readonly IntPtr NativeFieldInfoPtr_ABSORB_CD_TIME_MAX;

	// Token: 0x04004317 RID: 17175
	private static readonly IntPtr NativeFieldInfoPtr_FULL_TIMER_LIMIT;

	// Token: 0x04004318 RID: 17176
	private static readonly IntPtr NativeFieldInfoPtr_REPULSE_TIME_MAX;

	// Token: 0x04004319 RID: 17177
	private static readonly IntPtr NativeFieldInfoPtr_PRAYER_ATTACK_TIME_MAX;

	// Token: 0x0400431A RID: 17178
	private static readonly IntPtr NativeMethodInfoPtr_get_Controllable_Public_get_Boolean_0;

	// Token: 0x0400431B RID: 17179
	private static readonly IntPtr NativeMethodInfoPtr_get_IsDead_Public_get_Boolean_0;

	// Token: 0x0400431C RID: 17180
	private static readonly IntPtr NativeMethodInfoPtr_get_DeltaTime_Public_get_Single_0;

	// Token: 0x0400431D RID: 17181
	private static readonly IntPtr NativeMethodInfoPtr_get_TimeScale_Public_get_Single_0;

	// Token: 0x0400431E RID: 17182
	private static readonly IntPtr NativeMethodInfoPtr_get_MoveSpeed_Public_get_Single_0;

	// Token: 0x0400431F RID: 17183
	private static readonly IntPtr NativeMethodInfoPtr_get_JumpMoveSpeed_Public_get_Single_0;

	// Token: 0x04004320 RID: 17184
	private static readonly IntPtr NativeMethodInfoPtr_get_RotationSpeed_Public_get_Single_0;

	// Token: 0x04004321 RID: 17185
	private static readonly IntPtr NativeMethodInfoPtr_get_MoveSpeedScale_Public_get_Single_0;

	// Token: 0x04004322 RID: 17186
	private static readonly IntPtr NativeMethodInfoPtr_get_MoveDirection_Public_get_Vector3_0;

	// Token: 0x04004323 RID: 17187
	private static readonly IntPtr NativeMethodInfoPtr_get_JumpDirection_Public_get_Vector3_0;

	// Token: 0x04004324 RID: 17188
	private static readonly IntPtr NativeMethodInfoPtr_get_JumpForce_Public_get_Single_0;

	// Token: 0x04004325 RID: 17189
	private static readonly IntPtr NativeMethodInfoPtr_get_Gravity_Public_get_Single_0;

	// Token: 0x04004326 RID: 17190
	private static readonly IntPtr NativeMethodInfoPtr_get_IsPond_Public_get_Boolean_0;

	// Token: 0x04004327 RID: 17191
	private static readonly IntPtr NativeMethodInfoPtr_get_PondHeight_Public_get_Single_0;

	// Token: 0x04004328 RID: 17192
	private static readonly IntPtr NativeMethodInfoPtr_get_IsSky_Public_get_Boolean_0;

	// Token: 0x04004329 RID: 17193
	private static readonly IntPtr NativeMethodInfoPtr_get_FallSpeedMax_Public_get_Single_0;

	// Token: 0x0400432A RID: 17194
	private static readonly IntPtr NativeMethodInfoPtr_get_FallTimer_Public_get_Single_0;

	// Token: 0x0400432B RID: 17195
	private static readonly IntPtr NativeMethodInfoPtr_get_AimReadyWight_Public_get_Single_0;

	// Token: 0x0400432C RID: 17196
	private static readonly IntPtr NativeMethodInfoPtr_get_AimWight_Public_get_Single_0;

	// Token: 0x0400432D RID: 17197
	private static readonly IntPtr NativeMethodInfoPtr_get_HoldingShot_Public_get_Single_0;

	// Token: 0x0400432E RID: 17198
	private static readonly IntPtr NativeMethodInfoPtr_set_HoldingShot_Public_set_Void_Single_0;

	// Token: 0x0400432F RID: 17199
	private static readonly IntPtr NativeMethodInfoPtr_get_HPRecovery_Public_get_Single_0;

	// Token: 0x04004330 RID: 17200
	private static readonly IntPtr NativeMethodInfoPtr_get_MPRecovery_Public_get_Single_0;

	// Token: 0x04004331 RID: 17201
	private static readonly IntPtr NativeMethodInfoPtr_get_MPRecoveryExternal_Public_get_Single_0;

	// Token: 0x04004332 RID: 17202
	private static readonly IntPtr NativeMethodInfoPtr_get_MagicLockTargets_Public_get_Il2CppReferenceArray_1_Transform_0;

	// Token: 0x04004333 RID: 17203
	private static readonly IntPtr NativeMethodInfoPtr_get_HasMagicLockTargets_Public_get_Boolean_0;

	// Token: 0x04004334 RID: 17204
	private static readonly IntPtr NativeMethodInfoPtr_get_StaminaLossDodge_Public_get_Single_0;

	// Token: 0x04004335 RID: 17205
	private static readonly IntPtr NativeMethodInfoPtr_get_StaminaLossDash_Public_get_Single_0;

	// Token: 0x04004336 RID: 17206
	private static readonly IntPtr NativeMethodInfoPtr_get_StaminaLossFall_Public_get_Single_0;

	// Token: 0x04004337 RID: 17207
	private static readonly IntPtr NativeMethodInfoPtr_get_StaminaLossJump_Public_get_Single_0;

	// Token: 0x04004338 RID: 17208
	private static readonly IntPtr NativeMethodInfoPtr_get_AbsorbTimer_Public_get_Single_0;

	// Token: 0x04004339 RID: 17209
	private static readonly IntPtr NativeMethodInfoPtr_get_AbsorbCDTimer_Public_get_Single_0;

	// Token: 0x0400433A RID: 17210
	private static readonly IntPtr NativeMethodInfoPtr_get_AbsorbStatusTimer_Public_get_Single_0;

	// Token: 0x0400433B RID: 17211
	private static readonly IntPtr NativeMethodInfoPtr_get_IsSlip_Public_get_Boolean_0;

	// Token: 0x0400433C RID: 17212
	private static readonly IntPtr NativeMethodInfoPtr_get_IsChargeEnable_Public_get_Boolean_0;

	// Token: 0x0400433D RID: 17213
	private static readonly IntPtr NativeMethodInfoPtr_get_DodgeTimer_Public_get_Single_0;

	// Token: 0x0400433E RID: 17214
	private static readonly IntPtr NativeMethodInfoPtr_get_DamageDodgeTimer_Public_get_Single_0;

	// Token: 0x0400433F RID: 17215
	private static readonly IntPtr NativeMethodInfoPtr_get_ShotEffect_Public_get_Boolean_0;

	// Token: 0x04004340 RID: 17216
	private static readonly IntPtr NativeMethodInfoPtr_get_HardBody_Public_get_Boolean_0;

	// Token: 0x04004341 RID: 17217
	private static readonly IntPtr NativeMethodInfoPtr_get_DodgeDamage_Public_get_Boolean_0;

	// Token: 0x04004342 RID: 17218
	private static readonly IntPtr NativeMethodInfoPtr_get_PrayerAttackTimer_Public_get_Single_0;

	// Token: 0x04004343 RID: 17219
	private static readonly IntPtr NativeMethodInfoPtr_get_NextAttack_Public_get_Boolean_0;

	// Token: 0x04004344 RID: 17220
	private static readonly IntPtr NativeMethodInfoPtr_get_NextAirAttack_Public_get_Boolean_0;

	// Token: 0x04004345 RID: 17221
	private static readonly IntPtr NativeMethodInfoPtr_get_AirAttackTimer_Public_get_Single_0;

	// Token: 0x04004346 RID: 17222
	private static readonly IntPtr NativeMethodInfoPtr_get_WaitTime_Public_get_Single_0;

	// Token: 0x04004347 RID: 17223
	private static readonly IntPtr NativeMethodInfoPtr_get_NoFireWaitTime_Public_get_Single_0;

	// Token: 0x04004348 RID: 17224
	private static readonly IntPtr NativeMethodInfoPtr_get_AimTime_Public_get_Single_0;

	// Token: 0x04004349 RID: 17225
	private static readonly IntPtr NativeMethodInfoPtr_get_ShotTime_Public_get_Single_0;

	// Token: 0x0400434A RID: 17226
	private static readonly IntPtr NativeMethodInfoPtr_get_NextTime_Public_get_Single_0;

	// Token: 0x0400434B RID: 17227
	private static readonly IntPtr NativeMethodInfoPtr_get_NextEndTime_Public_get_Single_0;

	// Token: 0x0400434C RID: 17228
	private static readonly IntPtr NativeMethodInfoPtr_UpdateControllable_Public_Void_Boolean_0;

	// Token: 0x0400434D RID: 17229
	private static readonly IntPtr NativeMethodInfoPtr_UpdateIsDead_Public_Void_Boolean_0;

	// Token: 0x0400434E RID: 17230
	private static readonly IntPtr NativeMethodInfoPtr_UpdateTimeMembers_Public_Void_Single_0;

	// Token: 0x0400434F RID: 17231
	private static readonly IntPtr NativeMethodInfoPtr_UpdateMoveSpeed_Public_Void_Single_0;

	// Token: 0x04004350 RID: 17232
	private static readonly IntPtr NativeMethodInfoPtr_UpdateMoveDirection_Public_Void_Vector3_0;

	// Token: 0x04004351 RID: 17233
	private static readonly IntPtr NativeMethodInfoPtr_UpdateJumpDirection_Public_Void_0;

	// Token: 0x04004352 RID: 17234
	private static readonly IntPtr NativeMethodInfoPtr_UpdateJumpDirection_Public_Void_Transform_0;

	// Token: 0x04004353 RID: 17235
	private static readonly IntPtr NativeMethodInfoPtr_IncreaseDamagedAirStayTimer_Public_Void_0;

	// Token: 0x04004354 RID: 17236
	private static readonly IntPtr NativeMethodInfoPtr_ResetDamagedAirStayTimer_Public_Void_0;

	// Token: 0x04004355 RID: 17237
	private static readonly IntPtr NativeMethodInfoPtr_UpdateJumpMoveSpeed_Public_Void_Single_0;

	// Token: 0x04004356 RID: 17238
	private static readonly IntPtr NativeMethodInfoPtr_UpdateIsPond_Public_Void_Boolean_0;

	// Token: 0x04004357 RID: 17239
	private static readonly IntPtr NativeMethodInfoPtr_UpdatePondHeight_Public_Void_Single_0;

	// Token: 0x04004358 RID: 17240
	private static readonly IntPtr NativeMethodInfoPtr_UpdateIsSky_Public_Void_Boolean_0;

	// Token: 0x04004359 RID: 17241
	private static readonly IntPtr NativeMethodInfoPtr_UpdateFallTimer_Public_Void_Transform_0;

	// Token: 0x0400435A RID: 17242
	private static readonly IntPtr NativeMethodInfoPtr_UpdateAimReadyWight_Public_Void_Single_0;

	// Token: 0x0400435B RID: 17243
	private static readonly IntPtr NativeMethodInfoPtr_UpdateAimWight_Public_Void_Single_0;

	// Token: 0x0400435C RID: 17244
	private static readonly IntPtr NativeMethodInfoPtr_ResetAimWightValues_Public_Void_0;

	// Token: 0x0400435D RID: 17245
	private static readonly IntPtr NativeMethodInfoPtr_UpdateHPRecovery_Public_Void_Single_0;

	// Token: 0x0400435E RID: 17246
	private static readonly IntPtr NativeMethodInfoPtr_UpdateMPRecovery_Public_Void_Single_0;

	// Token: 0x0400435F RID: 17247
	private static readonly IntPtr NativeMethodInfoPtr_UpdateMPRecoveryExternal_Public_Void_Single_0;

	// Token: 0x04004360 RID: 17248
	private static readonly IntPtr NativeMethodInfoPtr_UpdateLockTargets_Public_Void_0;

	// Token: 0x04004361 RID: 17249
	private static readonly IntPtr NativeMethodInfoPtr_GetLockTarget_Public_Transform_0;

	// Token: 0x04004362 RID: 17250
	private static readonly IntPtr NativeMethodInfoPtr_DecreaseAbsorbTimers_Public_Void_0;

	// Token: 0x04004363 RID: 17251
	private static readonly IntPtr NativeMethodInfoPtr_ResetAbsorbTimers_Public_Void_0;

	// Token: 0x04004364 RID: 17252
	private static readonly IntPtr NativeMethodInfoPtr_ResetAbsorbStatusTimer_Public_Void_0;

	// Token: 0x04004365 RID: 17253
	private static readonly IntPtr NativeMethodInfoPtr_FillAbsorbTimer_Public_Void_0;

	// Token: 0x04004366 RID: 17254
	private static readonly IntPtr NativeMethodInfoPtr_FillAbsorbCDTimer_Public_Void_0;

	// Token: 0x04004367 RID: 17255
	private static readonly IntPtr NativeMethodInfoPtr_FillAbsorbStatusTimer_Public_Void_0;

	// Token: 0x04004368 RID: 17256
	private static readonly IntPtr NativeMethodInfoPtr_UpdateSlipFlag_Public_Void_Boolean_0;

	// Token: 0x04004369 RID: 17257
	private static readonly IntPtr NativeMethodInfoPtr_UpdateChargeEnabled_Public_Void_Boolean_0;

	// Token: 0x0400436A RID: 17258
	private static readonly IntPtr NativeMethodInfoPtr_ReverseChargeEnabled_Public_Void_0;

	// Token: 0x0400436B RID: 17259
	private static readonly IntPtr NativeMethodInfoPtr_DecreaseDodgeTimer_Public_Void_0;

	// Token: 0x0400436C RID: 17260
	private static readonly IntPtr NativeMethodInfoPtr_UpdateDodgeTimer_Public_Void_Single_0;

	// Token: 0x0400436D RID: 17261
	private static readonly IntPtr NativeMethodInfoPtr_DecreaseDamageDodgeTimer_Public_Void_0;

	// Token: 0x0400436E RID: 17262
	private static readonly IntPtr NativeMethodInfoPtr_UpdateDamageDodgeTimer_Public_Void_Single_0;

	// Token: 0x0400436F RID: 17263
	private static readonly IntPtr NativeMethodInfoPtr_UpdateShotEffect_Public_Void_Boolean_0;

	// Token: 0x04004370 RID: 17264
	private static readonly IntPtr NativeMethodInfoPtr_UpdateHardBody_Public_Void_Boolean_0;

	// Token: 0x04004371 RID: 17265
	private static readonly IntPtr NativeMethodInfoPtr_UpdateDodgeDamage_Public_Void_Boolean_0;

	// Token: 0x04004372 RID: 17266
	private static readonly IntPtr NativeMethodInfoPtr_FillPrayerAttackTimer_Public_Void_0;

	// Token: 0x04004373 RID: 17267
	private static readonly IntPtr NativeMethodInfoPtr_DecreasePrayerAttackTimer_Public_Void_0;

	// Token: 0x04004374 RID: 17268
	private static readonly IntPtr NativeMethodInfoPtr_UpdateNextAttack_Public_Void_Boolean_0;

	// Token: 0x04004375 RID: 17269
	private static readonly IntPtr NativeMethodInfoPtr_UpdateNextAirAttack_Public_Void_Boolean_0;

	// Token: 0x04004376 RID: 17270
	private static readonly IntPtr NativeMethodInfoPtr_UpdateAirAttackTimer_Public_Void_Single_0;

	// Token: 0x04004377 RID: 17271
	private static readonly IntPtr NativeMethodInfoPtr_IncreaseAirAttackTimer_Public_Void_Single_0;

	// Token: 0x04004378 RID: 17272
	private static readonly IntPtr NativeMethodInfoPtr_DecreaseAirAttackTimer_Public_Void_0;

	// Token: 0x04004379 RID: 17273
	private static readonly IntPtr NativeMethodInfoPtr_UpdateWaitTime_Public_Void_Single_0;

	// Token: 0x0400437A RID: 17274
	private static readonly IntPtr NativeMethodInfoPtr_DecreaseWaitTime_Public_Void_0;

	// Token: 0x0400437B RID: 17275
	private static readonly IntPtr NativeMethodInfoPtr_UpdateNoFireWaitTime_Public_Void_Single_0;

	// Token: 0x0400437C RID: 17276
	private static readonly IntPtr NativeMethodInfoPtr_DecreaseNoFireWaitTime_Public_Void_0;

	// Token: 0x0400437D RID: 17277
	private static readonly IntPtr NativeMethodInfoPtr_UpdateAimTime_Public_Void_Single_0;

	// Token: 0x0400437E RID: 17278
	private static readonly IntPtr NativeMethodInfoPtr_UpdateShotTime_Public_Void_Single_0;

	// Token: 0x0400437F RID: 17279
	private static readonly IntPtr NativeMethodInfoPtr_UpdateNextTime_Public_Void_Single_0;

	// Token: 0x04004380 RID: 17280
	private static readonly IntPtr NativeMethodInfoPtr_UpdateNextEndTime_Public_Void_Single_0;

	// Token: 0x04004381 RID: 17281
	private static readonly IntPtr NativeMethodInfoPtr_ResetAllCharacterValue_Public_Void_0;

	// Token: 0x04004382 RID: 17282
	private static readonly IntPtr NativeMethodInfoPtr_CalculateRepulseTimer_Public_Boolean_Single_0;

	// Token: 0x04004383 RID: 17283
	private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
}