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: 0x0200030C RID: 780
[Serializable]
public class NobetaRuntimeData : Il2CppSystem.Object
{
	// Token: 0x17002305 RID: 8965
	// (get) Token: 0x06006546 RID: 25926 RVA: 0x0019AA4C File Offset: 0x00198C4C
	public unsafe bool Controllable
	{
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 6792, RefRangeEnd = 6793, XrefRangeStart = 6792, XrefRangeEnd = 6793, 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: 0x17002306 RID: 8966
	// (get) Token: 0x06006547 RID: 25927 RVA: 0x0019AA9C File Offset: 0x00198C9C
	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: 0x17002307 RID: 8967
	// (get) Token: 0x06006548 RID: 25928 RVA: 0x0019AAEC File Offset: 0x00198CEC
	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: 0x17002308 RID: 8968
	// (get) Token: 0x06006549 RID: 25929 RVA: 0x0019AB3C File Offset: 0x00198D3C
	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: 0x17002309 RID: 8969
	// (get) Token: 0x0600654A RID: 25930 RVA: 0x0019AB8C File Offset: 0x00198D8C
	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: 0x1700230A RID: 8970
	// (get) Token: 0x0600654B RID: 25931 RVA: 0x0019ABDC File Offset: 0x00198DDC
	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: 0x1700230B RID: 8971
	// (get) Token: 0x0600654C RID: 25932 RVA: 0x0019AC2C File Offset: 0x00198E2C
	public unsafe float RotationSpeed
	{
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 592590, RefRangeEnd = 592591, XrefRangeStart = 592590, XrefRangeEnd = 592590, 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: 0x1700230C RID: 8972
	// (get) Token: 0x0600654D RID: 25933 RVA: 0x0019AC7C File Offset: 0x00198E7C
	public unsafe float MoveSpeedScale
	{
		[CallerCount(11)]
		[CachedScanResults(RefRangeStart = 592591, RefRangeEnd = 592602, XrefRangeStart = 592591, XrefRangeEnd = 592591, 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: 0x1700230D RID: 8973
	// (get) Token: 0x0600654E RID: 25934 RVA: 0x0019ACCC File Offset: 0x00198ECC
	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: 0x1700230E RID: 8974
	// (get) Token: 0x0600654F RID: 25935 RVA: 0x0019AD1C File Offset: 0x00198F1C
	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: 0x1700230F RID: 8975
	// (get) Token: 0x06006550 RID: 25936 RVA: 0x0019AD6C File Offset: 0x00198F6C
	public unsafe float JumpForce
	{
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 592602, RefRangeEnd = 592604, XrefRangeStart = 592602, XrefRangeEnd = 592602, 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: 0x17002310 RID: 8976
	// (get) Token: 0x06006551 RID: 25937 RVA: 0x0019ADBC File Offset: 0x00198FBC
	public unsafe float Gravity
	{
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 592604, RefRangeEnd = 592605, XrefRangeStart = 592604, XrefRangeEnd = 592604, 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: 0x17002311 RID: 8977
	// (get) Token: 0x06006552 RID: 25938 RVA: 0x0019AE0C File Offset: 0x0019900C
	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: 0x17002312 RID: 8978
	// (get) Token: 0x06006553 RID: 25939 RVA: 0x0019AE5C File Offset: 0x0019905C
	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: 0x17002313 RID: 8979
	// (get) Token: 0x06006554 RID: 25940 RVA: 0x0019AEAC File Offset: 0x001990AC
	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: 0x17002314 RID: 8980
	// (get) Token: 0x06006555 RID: 25941 RVA: 0x0019AEFC File Offset: 0x001990FC
	public unsafe float FallSpeedMax
	{
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 592605, RefRangeEnd = 592606, XrefRangeStart = 592605, XrefRangeEnd = 592605, 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: 0x17002315 RID: 8981
	// (get) Token: 0x06006556 RID: 25942 RVA: 0x0019AF4C File Offset: 0x0019914C
	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: 0x17002316 RID: 8982
	// (get) Token: 0x06006557 RID: 25943 RVA: 0x0019AF9C File Offset: 0x0019919C
	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: 0x17002317 RID: 8983
	// (get) Token: 0x06006558 RID: 25944 RVA: 0x0019AFEC File Offset: 0x001991EC
	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: 0x17002318 RID: 8984
	// (get) Token: 0x06006559 RID: 25945 RVA: 0x0019B03C File Offset: 0x0019923C
	// (set) Token: 0x0600655A RID: 25946 RVA: 0x0019B08C File Offset: 0x0019928C
	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: 0x17002319 RID: 8985
	// (get) Token: 0x0600655B RID: 25947 RVA: 0x0019B0E0 File Offset: 0x001992E0
	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: 0x1700231A RID: 8986
	// (get) Token: 0x0600655C RID: 25948 RVA: 0x0019B130 File Offset: 0x00199330
	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: 0x1700231B RID: 8987
	// (get) Token: 0x0600655D RID: 25949 RVA: 0x0019B180 File Offset: 0x00199380
	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: 0x1700231C RID: 8988
	// (get) Token: 0x0600655E RID: 25950 RVA: 0x0019B1D0 File Offset: 0x001993D0
	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: 0x1700231D RID: 8989
	// (get) Token: 0x0600655F RID: 25951 RVA: 0x0019B228 File Offset: 0x00199428
	public unsafe bool HasMagicLockTargets
	{
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 592606, RefRangeEnd = 592608, XrefRangeStart = 592606, XrefRangeEnd = 592606, 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: 0x1700231E RID: 8990
	// (get) Token: 0x06006560 RID: 25952 RVA: 0x0019B278 File Offset: 0x00199478
	public unsafe float StaminaLossDodge
	{
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 592608, RefRangeEnd = 592610, XrefRangeStart = 592608, XrefRangeEnd = 592608, 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: 0x1700231F RID: 8991
	// (get) Token: 0x06006561 RID: 25953 RVA: 0x0019B2C8 File Offset: 0x001994C8
	public unsafe float StaminaLossDash
	{
		[CallerCount(11)]
		[CachedScanResults(RefRangeStart = 592591, RefRangeEnd = 592602, XrefRangeStart = 592591, XrefRangeEnd = 592602, 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: 0x17002320 RID: 8992
	// (get) Token: 0x06006562 RID: 25954 RVA: 0x0019B318 File Offset: 0x00199518
	public unsafe float StaminaLossFall
	{
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 592610, RefRangeEnd = 592611, XrefRangeStart = 592610, XrefRangeEnd = 592610, 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: 0x17002321 RID: 8993
	// (get) Token: 0x06006563 RID: 25955 RVA: 0x0019B368 File Offset: 0x00199568
	public unsafe float StaminaLossJump
	{
		[CallerCount(11)]
		[CachedScanResults(RefRangeStart = 592591, RefRangeEnd = 592602, XrefRangeStart = 592591, XrefRangeEnd = 592602, 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: 0x17002322 RID: 8994
	// (get) Token: 0x06006564 RID: 25956 RVA: 0x0019B3B8 File Offset: 0x001995B8
	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: 0x17002323 RID: 8995
	// (get) Token: 0x06006565 RID: 25957 RVA: 0x0019B408 File Offset: 0x00199608
	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: 0x17002324 RID: 8996
	// (get) Token: 0x06006566 RID: 25958 RVA: 0x0019B458 File Offset: 0x00199658
	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: 0x17002325 RID: 8997
	// (get) Token: 0x06006567 RID: 25959 RVA: 0x0019B4A8 File Offset: 0x001996A8
	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: 0x17002326 RID: 8998
	// (get) Token: 0x06006568 RID: 25960 RVA: 0x0019B4F8 File Offset: 0x001996F8
	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: 0x17002327 RID: 8999
	// (get) Token: 0x06006569 RID: 25961 RVA: 0x0019B548 File Offset: 0x00199748
	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: 0x17002328 RID: 9000
	// (get) Token: 0x0600656A RID: 25962 RVA: 0x0019B598 File Offset: 0x00199798
	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: 0x17002329 RID: 9001
	// (get) Token: 0x0600656B RID: 25963 RVA: 0x0019B5E8 File Offset: 0x001997E8
	public unsafe bool ShotEffect
	{
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 24394, RefRangeEnd = 24395, XrefRangeStart = 24394, XrefRangeEnd = 24395, 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: 0x1700232A RID: 9002
	// (get) Token: 0x0600656C RID: 25964 RVA: 0x0019B638 File Offset: 0x00199838
	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: 0x1700232B RID: 9003
	// (get) Token: 0x0600656D RID: 25965 RVA: 0x0019B688 File Offset: 0x00199888
	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: 0x1700232C RID: 9004
	// (get) Token: 0x0600656E RID: 25966 RVA: 0x0019B6D8 File Offset: 0x001998D8
	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: 0x1700232D RID: 9005
	// (get) Token: 0x0600656F RID: 25967 RVA: 0x0019B728 File Offset: 0x00199928
	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: 0x1700232E RID: 9006
	// (get) Token: 0x06006570 RID: 25968 RVA: 0x0019B778 File Offset: 0x00199978
	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: 0x1700232F RID: 9007
	// (get) Token: 0x06006571 RID: 25969 RVA: 0x0019B7C8 File Offset: 0x001999C8
	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: 0x17002330 RID: 9008
	// (get) Token: 0x06006572 RID: 25970 RVA: 0x0019B818 File Offset: 0x00199A18
	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: 0x17002331 RID: 9009
	// (get) Token: 0x06006573 RID: 25971 RVA: 0x0019B868 File Offset: 0x00199A68
	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: 0x17002332 RID: 9010
	// (get) Token: 0x06006574 RID: 25972 RVA: 0x0019B8B8 File Offset: 0x00199AB8
	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: 0x17002333 RID: 9011
	// (get) Token: 0x06006575 RID: 25973 RVA: 0x0019B908 File Offset: 0x00199B08
	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: 0x17002334 RID: 9012
	// (get) Token: 0x06006576 RID: 25974 RVA: 0x0019B958 File Offset: 0x00199B58
	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: 0x17002335 RID: 9013
	// (get) Token: 0x06006577 RID: 25975 RVA: 0x0019B9A8 File Offset: 0x00199BA8
	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: 0x06006578 RID: 25976 RVA: 0x0019B9F8 File Offset: 0x00199BF8
	[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: 0x06006579 RID: 25977 RVA: 0x0019BA4C File Offset: 0x00199C4C
	[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: 0x0600657A RID: 25978 RVA: 0x0019BAA0 File Offset: 0x00199CA0
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 592615, RefRangeEnd = 592616, XrefRangeStart = 592611, XrefRangeEnd = 592615, 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: 0x0600657B RID: 25979 RVA: 0x0019BAF4 File Offset: 0x00199CF4
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 221809, RefRangeEnd = 221813, XrefRangeStart = 221809, XrefRangeEnd = 221813, 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: 0x0600657C RID: 25980 RVA: 0x0019BB48 File Offset: 0x00199D48
	[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: 0x0600657D RID: 25981 RVA: 0x0019BB9C File Offset: 0x00199D9C
	[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: 0x0600657E RID: 25982 RVA: 0x0019BBE0 File Offset: 0x00199DE0
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 592620, RefRangeEnd = 592621, XrefRangeStart = 592616, XrefRangeEnd = 592620, 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: 0x0600657F RID: 25983 RVA: 0x0019BC3C File Offset: 0x00199E3C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 592621, RefRangeEnd = 592622, XrefRangeStart = 592621, XrefRangeEnd = 592621, 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: 0x06006580 RID: 25984 RVA: 0x0019BC80 File Offset: 0x00199E80
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 592622, RefRangeEnd = 592626, XrefRangeStart = 592622, XrefRangeEnd = 592622, 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: 0x06006581 RID: 25985 RVA: 0x0019BCC4 File Offset: 0x00199EC4
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 223830, RefRangeEnd = 223831, XrefRangeStart = 223830, XrefRangeEnd = 223831, 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: 0x06006582 RID: 25986 RVA: 0x0019BD18 File Offset: 0x00199F18
	[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: 0x06006583 RID: 25987 RVA: 0x0019BD6C File Offset: 0x00199F6C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 223880, RefRangeEnd = 223881, XrefRangeStart = 223880, XrefRangeEnd = 223881, 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: 0x06006584 RID: 25988 RVA: 0x0019BDC0 File Offset: 0x00199FC0
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 592626, RefRangeEnd = 592627, XrefRangeStart = 592626, XrefRangeEnd = 592626, 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: 0x06006585 RID: 25989 RVA: 0x0019BE14 File Offset: 0x0019A014
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 592630, RefRangeEnd = 592631, XrefRangeStart = 592627, XrefRangeEnd = 592630, 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: 0x06006586 RID: 25990 RVA: 0x0019BE70 File Offset: 0x0019A070
	[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: 0x06006587 RID: 25991 RVA: 0x0019BEC4 File Offset: 0x0019A0C4
	[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: 0x06006588 RID: 25992 RVA: 0x0019BF18 File Offset: 0x0019A118
	[CallerCount(9)]
	[CachedScanResults(RefRangeStart = 592631, RefRangeEnd = 592640, XrefRangeStart = 592631, XrefRangeEnd = 592631, 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: 0x06006589 RID: 25993 RVA: 0x0019BF5C File Offset: 0x0019A15C
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 592640, RefRangeEnd = 592642, XrefRangeStart = 592640, XrefRangeEnd = 592640, 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: 0x0600658A RID: 25994 RVA: 0x0019BFB0 File Offset: 0x0019A1B0
	[CallerCount(3)]
	[CachedScanResults(RefRangeStart = 592642, RefRangeEnd = 592645, XrefRangeStart = 592642, XrefRangeEnd = 592642, 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: 0x0600658B RID: 25995 RVA: 0x0019C004 File Offset: 0x0019A204
	[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: 0x0600658C RID: 25996 RVA: 0x0019C058 File Offset: 0x0019A258
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 592652, RefRangeEnd = 592654, XrefRangeStart = 592645, XrefRangeEnd = 592652, 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: 0x0600658D RID: 25997 RVA: 0x0019C09C File Offset: 0x0019A29C
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 592654, RefRangeEnd = 592656, XrefRangeStart = 592654, XrefRangeEnd = 592654, 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: 0x0600658E RID: 25998 RVA: 0x0019C0F4 File Offset: 0x0019A2F4
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 592659, RefRangeEnd = 592660, XrefRangeStart = 592656, XrefRangeEnd = 592659, 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: 0x0600658F RID: 25999 RVA: 0x0019C138 File Offset: 0x0019A338
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 592660, RefRangeEnd = 592662, XrefRangeStart = 592660, XrefRangeEnd = 592660, 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: 0x06006590 RID: 26000 RVA: 0x0019C17C File Offset: 0x0019A37C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 592662, RefRangeEnd = 592663, XrefRangeStart = 592662, XrefRangeEnd = 592662, 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: 0x06006591 RID: 26001 RVA: 0x0019C1C0 File Offset: 0x0019A3C0
	[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: 0x06006592 RID: 26002 RVA: 0x0019C204 File Offset: 0x0019A404
	[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: 0x06006593 RID: 26003 RVA: 0x0019C248 File Offset: 0x0019A448
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 592663, RefRangeEnd = 592664, XrefRangeStart = 592663, XrefRangeEnd = 592663, 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: 0x06006594 RID: 26004 RVA: 0x0019C28C File Offset: 0x0019A48C
	[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: 0x06006595 RID: 26005 RVA: 0x0019C2E0 File Offset: 0x0019A4E0
	[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: 0x06006596 RID: 26006 RVA: 0x0019C334 File Offset: 0x0019A534
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 592664, RefRangeEnd = 592665, XrefRangeStart = 592664, XrefRangeEnd = 592664, 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: 0x06006597 RID: 26007 RVA: 0x0019C378 File Offset: 0x0019A578
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 592666, RefRangeEnd = 592667, XrefRangeStart = 592665, XrefRangeEnd = 592666, 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: 0x06006598 RID: 26008 RVA: 0x0019C3BC File Offset: 0x0019A5BC
	[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: 0x06006599 RID: 26009 RVA: 0x0019C410 File Offset: 0x0019A610
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 592672, RefRangeEnd = 592673, XrefRangeStart = 592667, XrefRangeEnd = 592672, 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: 0x0600659A RID: 26010 RVA: 0x0019C454 File Offset: 0x0019A654
	[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: 0x0600659B RID: 26011 RVA: 0x0019C4A8 File Offset: 0x0019A6A8
	[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: 0x0600659C RID: 26012 RVA: 0x0019C4FC File Offset: 0x0019A6FC
	[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: 0x0600659D RID: 26013 RVA: 0x0019C550 File Offset: 0x0019A750
	[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: 0x0600659E RID: 26014 RVA: 0x0019C5A4 File Offset: 0x0019A7A4
	[CallerCount(3)]
	[CachedScanResults(RefRangeStart = 592673, RefRangeEnd = 592676, XrefRangeStart = 592673, XrefRangeEnd = 592673, 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: 0x0600659F RID: 26015 RVA: 0x0019C5E8 File Offset: 0x0019A7E8
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 592677, RefRangeEnd = 592678, XrefRangeStart = 592676, XrefRangeEnd = 592677, 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: 0x060065A0 RID: 26016 RVA: 0x0019C62C File Offset: 0x0019A82C
	[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: 0x060065A1 RID: 26017 RVA: 0x0019C680 File Offset: 0x0019A880
	[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: 0x060065A2 RID: 26018 RVA: 0x0019C6D4 File Offset: 0x0019A8D4
	[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: 0x060065A3 RID: 26019 RVA: 0x0019C728 File Offset: 0x0019A928
	[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: 0x060065A4 RID: 26020 RVA: 0x0019C77C File Offset: 0x0019A97C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 592679, RefRangeEnd = 592680, XrefRangeStart = 592678, XrefRangeEnd = 592679, 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: 0x060065A5 RID: 26021 RVA: 0x0019C7C0 File Offset: 0x0019A9C0
	[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: 0x060065A6 RID: 26022 RVA: 0x0019C814 File Offset: 0x0019AA14
	[CallerCount(23)]
	[CachedScanResults(RefRangeStart = 592681, RefRangeEnd = 592704, XrefRangeStart = 592680, XrefRangeEnd = 592681, 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: 0x060065A7 RID: 26023 RVA: 0x0019C858 File Offset: 0x0019AA58
	[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: 0x060065A8 RID: 26024 RVA: 0x0019C8AC File Offset: 0x0019AAAC
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 592705, RefRangeEnd = 592707, XrefRangeStart = 592704, XrefRangeEnd = 592705, 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: 0x060065A9 RID: 26025 RVA: 0x0019C8F0 File Offset: 0x0019AAF0
	[CallerCount(5)]
	[CachedScanResults(RefRangeStart = 592707, RefRangeEnd = 592712, XrefRangeStart = 592707, XrefRangeEnd = 592707, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void ResetNoFireWaitTime()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(NobetaRuntimeData.NativeMethodInfoPtr_ResetNoFireWaitTime_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x060065AA RID: 26026 RVA: 0x0019C934 File Offset: 0x0019AB34
	[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: 0x060065AB RID: 26027 RVA: 0x0019C988 File Offset: 0x0019AB88
	[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: 0x060065AC RID: 26028 RVA: 0x0019C9DC File Offset: 0x0019ABDC
	[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: 0x060065AD RID: 26029 RVA: 0x0019CA30 File Offset: 0x0019AC30
	[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: 0x060065AE RID: 26030 RVA: 0x0019CA84 File Offset: 0x0019AC84
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 592622, RefRangeEnd = 592626, XrefRangeStart = 592622, XrefRangeEnd = 592626, 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: 0x060065AF RID: 26031 RVA: 0x0019CAC8 File Offset: 0x0019ACC8
	[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: 0x060065B0 RID: 26032 RVA: 0x0019CB2C File Offset: 0x0019AD2C
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 592712, XrefRangeEnd = 592714, 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: 0x060065B1 RID: 26033 RVA: 0x0019CB78 File Offset: 0x0019AD78
	// 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, 100670742);
		NobetaRuntimeData.NativeMethodInfoPtr_get_IsDead_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670743);
		NobetaRuntimeData.NativeMethodInfoPtr_get_DeltaTime_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670744);
		NobetaRuntimeData.NativeMethodInfoPtr_get_TimeScale_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670745);
		NobetaRuntimeData.NativeMethodInfoPtr_get_MoveSpeed_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670746);
		NobetaRuntimeData.NativeMethodInfoPtr_get_JumpMoveSpeed_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670747);
		NobetaRuntimeData.NativeMethodInfoPtr_get_RotationSpeed_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670748);
		NobetaRuntimeData.NativeMethodInfoPtr_get_MoveSpeedScale_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670749);
		NobetaRuntimeData.NativeMethodInfoPtr_get_MoveDirection_Public_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670750);
		NobetaRuntimeData.NativeMethodInfoPtr_get_JumpDirection_Public_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670751);
		NobetaRuntimeData.NativeMethodInfoPtr_get_JumpForce_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670752);
		NobetaRuntimeData.NativeMethodInfoPtr_get_Gravity_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670753);
		NobetaRuntimeData.NativeMethodInfoPtr_get_IsPond_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670754);
		NobetaRuntimeData.NativeMethodInfoPtr_get_PondHeight_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670755);
		NobetaRuntimeData.NativeMethodInfoPtr_get_IsSky_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670756);
		NobetaRuntimeData.NativeMethodInfoPtr_get_FallSpeedMax_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670757);
		NobetaRuntimeData.NativeMethodInfoPtr_get_FallTimer_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670758);
		NobetaRuntimeData.NativeMethodInfoPtr_get_AimReadyWight_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670759);
		NobetaRuntimeData.NativeMethodInfoPtr_get_AimWight_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670760);
		NobetaRuntimeData.NativeMethodInfoPtr_get_HoldingShot_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670761);
		NobetaRuntimeData.NativeMethodInfoPtr_set_HoldingShot_Public_set_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670762);
		NobetaRuntimeData.NativeMethodInfoPtr_get_HPRecovery_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670763);
		NobetaRuntimeData.NativeMethodInfoPtr_get_MPRecovery_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670764);
		NobetaRuntimeData.NativeMethodInfoPtr_get_MPRecoveryExternal_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670765);
		NobetaRuntimeData.NativeMethodInfoPtr_get_MagicLockTargets_Public_get_Il2CppReferenceArray_1_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670766);
		NobetaRuntimeData.NativeMethodInfoPtr_get_HasMagicLockTargets_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670767);
		NobetaRuntimeData.NativeMethodInfoPtr_get_StaminaLossDodge_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670768);
		NobetaRuntimeData.NativeMethodInfoPtr_get_StaminaLossDash_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670769);
		NobetaRuntimeData.NativeMethodInfoPtr_get_StaminaLossFall_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670770);
		NobetaRuntimeData.NativeMethodInfoPtr_get_StaminaLossJump_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670771);
		NobetaRuntimeData.NativeMethodInfoPtr_get_AbsorbTimer_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670772);
		NobetaRuntimeData.NativeMethodInfoPtr_get_AbsorbCDTimer_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670773);
		NobetaRuntimeData.NativeMethodInfoPtr_get_AbsorbStatusTimer_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670774);
		NobetaRuntimeData.NativeMethodInfoPtr_get_IsSlip_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670775);
		NobetaRuntimeData.NativeMethodInfoPtr_get_IsChargeEnable_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670776);
		NobetaRuntimeData.NativeMethodInfoPtr_get_DodgeTimer_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670777);
		NobetaRuntimeData.NativeMethodInfoPtr_get_DamageDodgeTimer_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670778);
		NobetaRuntimeData.NativeMethodInfoPtr_get_ShotEffect_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670779);
		NobetaRuntimeData.NativeMethodInfoPtr_get_HardBody_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670780);
		NobetaRuntimeData.NativeMethodInfoPtr_get_DodgeDamage_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670781);
		NobetaRuntimeData.NativeMethodInfoPtr_get_PrayerAttackTimer_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670782);
		NobetaRuntimeData.NativeMethodInfoPtr_get_NextAttack_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670783);
		NobetaRuntimeData.NativeMethodInfoPtr_get_NextAirAttack_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670784);
		NobetaRuntimeData.NativeMethodInfoPtr_get_AirAttackTimer_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670785);
		NobetaRuntimeData.NativeMethodInfoPtr_get_WaitTime_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670786);
		NobetaRuntimeData.NativeMethodInfoPtr_get_NoFireWaitTime_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670787);
		NobetaRuntimeData.NativeMethodInfoPtr_get_AimTime_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670788);
		NobetaRuntimeData.NativeMethodInfoPtr_get_ShotTime_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670789);
		NobetaRuntimeData.NativeMethodInfoPtr_get_NextTime_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670790);
		NobetaRuntimeData.NativeMethodInfoPtr_get_NextEndTime_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670791);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateControllable_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670792);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateIsDead_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670793);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateTimeMembers_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670794);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateMoveSpeed_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670795);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateMoveDirection_Public_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670796);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateJumpDirection_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670797);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateJumpDirection_Public_Void_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670798);
		NobetaRuntimeData.NativeMethodInfoPtr_IncreaseDamagedAirStayTimer_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670799);
		NobetaRuntimeData.NativeMethodInfoPtr_ResetDamagedAirStayTimer_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670800);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateJumpMoveSpeed_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670801);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateIsPond_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670802);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdatePondHeight_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670803);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateIsSky_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670804);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateFallTimer_Public_Void_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670805);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateAimReadyWight_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670806);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateAimWight_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670807);
		NobetaRuntimeData.NativeMethodInfoPtr_ResetAimWightValues_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670808);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateHPRecovery_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670809);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateMPRecovery_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670810);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateMPRecoveryExternal_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670811);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateLockTargets_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670812);
		NobetaRuntimeData.NativeMethodInfoPtr_GetLockTarget_Public_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670813);
		NobetaRuntimeData.NativeMethodInfoPtr_DecreaseAbsorbTimers_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670814);
		NobetaRuntimeData.NativeMethodInfoPtr_ResetAbsorbTimers_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670815);
		NobetaRuntimeData.NativeMethodInfoPtr_ResetAbsorbStatusTimer_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670816);
		NobetaRuntimeData.NativeMethodInfoPtr_FillAbsorbTimer_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670817);
		NobetaRuntimeData.NativeMethodInfoPtr_FillAbsorbCDTimer_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670818);
		NobetaRuntimeData.NativeMethodInfoPtr_FillAbsorbStatusTimer_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670819);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateSlipFlag_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670820);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateChargeEnabled_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670821);
		NobetaRuntimeData.NativeMethodInfoPtr_ReverseChargeEnabled_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670822);
		NobetaRuntimeData.NativeMethodInfoPtr_DecreaseDodgeTimer_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670823);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateDodgeTimer_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670824);
		NobetaRuntimeData.NativeMethodInfoPtr_DecreaseDamageDodgeTimer_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670825);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateDamageDodgeTimer_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670826);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateShotEffect_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670827);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateHardBody_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670828);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateDodgeDamage_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670829);
		NobetaRuntimeData.NativeMethodInfoPtr_FillPrayerAttackTimer_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670830);
		NobetaRuntimeData.NativeMethodInfoPtr_DecreasePrayerAttackTimer_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670831);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateNextAttack_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670832);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateNextAirAttack_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670833);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateAirAttackTimer_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670834);
		NobetaRuntimeData.NativeMethodInfoPtr_IncreaseAirAttackTimer_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670835);
		NobetaRuntimeData.NativeMethodInfoPtr_DecreaseAirAttackTimer_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670836);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateWaitTime_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670837);
		NobetaRuntimeData.NativeMethodInfoPtr_DecreaseWaitTime_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670838);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateNoFireWaitTime_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670839);
		NobetaRuntimeData.NativeMethodInfoPtr_DecreaseNoFireWaitTime_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670840);
		NobetaRuntimeData.NativeMethodInfoPtr_ResetNoFireWaitTime_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670841);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateAimTime_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670842);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateShotTime_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670843);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateNextTime_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670844);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateNextEndTime_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670845);
		NobetaRuntimeData.NativeMethodInfoPtr_ResetAllCharacterValue_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670846);
		NobetaRuntimeData.NativeMethodInfoPtr_CalculateRepulseTimer_Public_Boolean_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670847);
		NobetaRuntimeData.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100670848);
	}

	// Token: 0x060065B2 RID: 26034 RVA: 0x0000A74C File Offset: 0x0000894C
	public NobetaRuntimeData(IntPtr pointer)
		: base(pointer)
	{
	}

	// Token: 0x170022D5 RID: 8917
	// (get) Token: 0x060065B3 RID: 26035 RVA: 0x0019D7C4 File Offset: 0x0019B9C4
	// (set) Token: 0x060065B4 RID: 26036 RVA: 0x0019D7EC File Offset: 0x0019B9EC
	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: 0x170022D6 RID: 8918
	// (get) Token: 0x060065B5 RID: 26037 RVA: 0x0019D810 File Offset: 0x0019BA10
	// (set) Token: 0x060065B6 RID: 26038 RVA: 0x0019D838 File Offset: 0x0019BA38
	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: 0x170022D7 RID: 8919
	// (get) Token: 0x060065B7 RID: 26039 RVA: 0x0019D85C File Offset: 0x0019BA5C
	// (set) Token: 0x060065B8 RID: 26040 RVA: 0x0019D884 File Offset: 0x0019BA84
	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: 0x170022D8 RID: 8920
	// (get) Token: 0x060065B9 RID: 26041 RVA: 0x0019D8A8 File Offset: 0x0019BAA8
	// (set) Token: 0x060065BA RID: 26042 RVA: 0x0019D8D0 File Offset: 0x0019BAD0
	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: 0x170022D9 RID: 8921
	// (get) Token: 0x060065BB RID: 26043 RVA: 0x0019D8F4 File Offset: 0x0019BAF4
	// (set) Token: 0x060065BC RID: 26044 RVA: 0x0019D91C File Offset: 0x0019BB1C
	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: 0x170022DA RID: 8922
	// (get) Token: 0x060065BD RID: 26045 RVA: 0x0019D940 File Offset: 0x0019BB40
	// (set) Token: 0x060065BE RID: 26046 RVA: 0x0019D968 File Offset: 0x0019BB68
	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: 0x170022DB RID: 8923
	// (get) Token: 0x060065BF RID: 26047 RVA: 0x0019D98C File Offset: 0x0019BB8C
	// (set) Token: 0x060065C0 RID: 26048 RVA: 0x0019D9B4 File Offset: 0x0019BBB4
	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: 0x170022DC RID: 8924
	// (get) Token: 0x060065C1 RID: 26049 RVA: 0x0019D9D8 File Offset: 0x0019BBD8
	// (set) Token: 0x060065C2 RID: 26050 RVA: 0x0019DA00 File Offset: 0x0019BC00
	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: 0x170022DD RID: 8925
	// (get) Token: 0x060065C3 RID: 26051 RVA: 0x0019DA24 File Offset: 0x0019BC24
	// (set) Token: 0x060065C4 RID: 26052 RVA: 0x0019DA4C File Offset: 0x0019BC4C
	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: 0x170022DE RID: 8926
	// (get) Token: 0x060065C5 RID: 26053 RVA: 0x0019DA70 File Offset: 0x0019BC70
	// (set) Token: 0x060065C6 RID: 26054 RVA: 0x0019DA98 File Offset: 0x0019BC98
	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: 0x170022DF RID: 8927
	// (get) Token: 0x060065C7 RID: 26055 RVA: 0x0019DABC File Offset: 0x0019BCBC
	// (set) Token: 0x060065C8 RID: 26056 RVA: 0x0019DAE4 File Offset: 0x0019BCE4
	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: 0x170022E0 RID: 8928
	// (get) Token: 0x060065C9 RID: 26057 RVA: 0x0019DB08 File Offset: 0x0019BD08
	// (set) Token: 0x060065CA RID: 26058 RVA: 0x0019DB30 File Offset: 0x0019BD30
	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: 0x170022E1 RID: 8929
	// (get) Token: 0x060065CB RID: 26059 RVA: 0x0019DB54 File Offset: 0x0019BD54
	// (set) Token: 0x060065CC RID: 26060 RVA: 0x0019DB7C File Offset: 0x0019BD7C
	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: 0x170022E2 RID: 8930
	// (get) Token: 0x060065CD RID: 26061 RVA: 0x0019DBA0 File Offset: 0x0019BDA0
	// (set) Token: 0x060065CE RID: 26062 RVA: 0x0019DBC8 File Offset: 0x0019BDC8
	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: 0x170022E3 RID: 8931
	// (get) Token: 0x060065CF RID: 26063 RVA: 0x0019DBEC File Offset: 0x0019BDEC
	// (set) Token: 0x060065D0 RID: 26064 RVA: 0x0019DC14 File Offset: 0x0019BE14
	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: 0x170022E4 RID: 8932
	// (get) Token: 0x060065D1 RID: 26065 RVA: 0x0019DC38 File Offset: 0x0019BE38
	// (set) Token: 0x060065D2 RID: 26066 RVA: 0x0019DC60 File Offset: 0x0019BE60
	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: 0x170022E5 RID: 8933
	// (get) Token: 0x060065D3 RID: 26067 RVA: 0x0019DC84 File Offset: 0x0019BE84
	// (set) Token: 0x060065D4 RID: 26068 RVA: 0x0019DCAC File Offset: 0x0019BEAC
	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: 0x170022E6 RID: 8934
	// (get) Token: 0x060065D5 RID: 26069 RVA: 0x0019DCD0 File Offset: 0x0019BED0
	// (set) Token: 0x060065D6 RID: 26070 RVA: 0x0019DCF8 File Offset: 0x0019BEF8
	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: 0x170022E7 RID: 8935
	// (get) Token: 0x060065D7 RID: 26071 RVA: 0x0019DD1C File Offset: 0x0019BF1C
	// (set) Token: 0x060065D8 RID: 26072 RVA: 0x0019DD44 File Offset: 0x0019BF44
	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: 0x170022E8 RID: 8936
	// (get) Token: 0x060065D9 RID: 26073 RVA: 0x0019DD68 File Offset: 0x0019BF68
	// (set) Token: 0x060065DA RID: 26074 RVA: 0x0019DD90 File Offset: 0x0019BF90
	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: 0x170022E9 RID: 8937
	// (get) Token: 0x060065DB RID: 26075 RVA: 0x0019DDB4 File Offset: 0x0019BFB4
	// (set) Token: 0x060065DC RID: 26076 RVA: 0x0019DDE8 File Offset: 0x0019BFE8
	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: 0x170022EA RID: 8938
	// (get) Token: 0x060065DD RID: 26077 RVA: 0x0019DE10 File Offset: 0x0019C010
	// (set) Token: 0x060065DE RID: 26078 RVA: 0x0019DE38 File Offset: 0x0019C038
	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: 0x170022EB RID: 8939
	// (get) Token: 0x060065DF RID: 26079 RVA: 0x0019DE5C File Offset: 0x0019C05C
	// (set) Token: 0x060065E0 RID: 26080 RVA: 0x0019DE84 File Offset: 0x0019C084
	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: 0x170022EC RID: 8940
	// (get) Token: 0x060065E1 RID: 26081 RVA: 0x0019DEA8 File Offset: 0x0019C0A8
	// (set) Token: 0x060065E2 RID: 26082 RVA: 0x0019DED0 File Offset: 0x0019C0D0
	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: 0x170022ED RID: 8941
	// (get) Token: 0x060065E3 RID: 26083 RVA: 0x0019DEF4 File Offset: 0x0019C0F4
	// (set) Token: 0x060065E4 RID: 26084 RVA: 0x0019DF1C File Offset: 0x0019C11C
	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: 0x170022EE RID: 8942
	// (get) Token: 0x060065E5 RID: 26085 RVA: 0x0019DF40 File Offset: 0x0019C140
	// (set) Token: 0x060065E6 RID: 26086 RVA: 0x0019DF68 File Offset: 0x0019C168
	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: 0x170022EF RID: 8943
	// (get) Token: 0x060065E7 RID: 26087 RVA: 0x0019DF8C File Offset: 0x0019C18C
	// (set) Token: 0x060065E8 RID: 26088 RVA: 0x0019DFB4 File Offset: 0x0019C1B4
	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: 0x170022F0 RID: 8944
	// (get) Token: 0x060065E9 RID: 26089 RVA: 0x0019DFD8 File Offset: 0x0019C1D8
	// (set) Token: 0x060065EA RID: 26090 RVA: 0x0019E000 File Offset: 0x0019C200
	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: 0x170022F1 RID: 8945
	// (get) Token: 0x060065EB RID: 26091 RVA: 0x0019E024 File Offset: 0x0019C224
	// (set) Token: 0x060065EC RID: 26092 RVA: 0x0019E04C File Offset: 0x0019C24C
	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: 0x170022F2 RID: 8946
	// (get) Token: 0x060065ED RID: 26093 RVA: 0x0019E070 File Offset: 0x0019C270
	// (set) Token: 0x060065EE RID: 26094 RVA: 0x0019E098 File Offset: 0x0019C298
	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: 0x170022F3 RID: 8947
	// (get) Token: 0x060065EF RID: 26095 RVA: 0x0019E0BC File Offset: 0x0019C2BC
	// (set) Token: 0x060065F0 RID: 26096 RVA: 0x0019E0E4 File Offset: 0x0019C2E4
	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: 0x170022F4 RID: 8948
	// (get) Token: 0x060065F1 RID: 26097 RVA: 0x0019E108 File Offset: 0x0019C308
	// (set) Token: 0x060065F2 RID: 26098 RVA: 0x0019E130 File Offset: 0x0019C330
	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: 0x170022F5 RID: 8949
	// (get) Token: 0x060065F3 RID: 26099 RVA: 0x0019E154 File Offset: 0x0019C354
	// (set) Token: 0x060065F4 RID: 26100 RVA: 0x0019E17C File Offset: 0x0019C37C
	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: 0x170022F6 RID: 8950
	// (get) Token: 0x060065F5 RID: 26101 RVA: 0x0019E1A0 File Offset: 0x0019C3A0
	// (set) Token: 0x060065F6 RID: 26102 RVA: 0x0019E1C8 File Offset: 0x0019C3C8
	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: 0x170022F7 RID: 8951
	// (get) Token: 0x060065F7 RID: 26103 RVA: 0x0019E1EC File Offset: 0x0019C3EC
	// (set) Token: 0x060065F8 RID: 26104 RVA: 0x0019E214 File Offset: 0x0019C414
	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: 0x170022F8 RID: 8952
	// (get) Token: 0x060065F9 RID: 26105 RVA: 0x0019E238 File Offset: 0x0019C438
	// (set) Token: 0x060065FA RID: 26106 RVA: 0x0019E260 File Offset: 0x0019C460
	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: 0x170022F9 RID: 8953
	// (get) Token: 0x060065FB RID: 26107 RVA: 0x0019E284 File Offset: 0x0019C484
	// (set) Token: 0x060065FC RID: 26108 RVA: 0x0019E2AC File Offset: 0x0019C4AC
	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: 0x170022FA RID: 8954
	// (get) Token: 0x060065FD RID: 26109 RVA: 0x0019E2D0 File Offset: 0x0019C4D0
	// (set) Token: 0x060065FE RID: 26110 RVA: 0x0019E2F8 File Offset: 0x0019C4F8
	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: 0x170022FB RID: 8955
	// (get) Token: 0x060065FF RID: 26111 RVA: 0x0019E31C File Offset: 0x0019C51C
	// (set) Token: 0x06006600 RID: 26112 RVA: 0x0019E344 File Offset: 0x0019C544
	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: 0x170022FC RID: 8956
	// (get) Token: 0x06006601 RID: 26113 RVA: 0x0019E368 File Offset: 0x0019C568
	// (set) Token: 0x06006602 RID: 26114 RVA: 0x0019E390 File Offset: 0x0019C590
	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: 0x170022FD RID: 8957
	// (get) Token: 0x06006603 RID: 26115 RVA: 0x0019E3B4 File Offset: 0x0019C5B4
	// (set) Token: 0x06006604 RID: 26116 RVA: 0x0019E3DC File Offset: 0x0019C5DC
	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: 0x170022FE RID: 8958
	// (get) Token: 0x06006605 RID: 26117 RVA: 0x0019E400 File Offset: 0x0019C600
	// (set) Token: 0x06006606 RID: 26118 RVA: 0x0019E428 File Offset: 0x0019C628
	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: 0x170022FF RID: 8959
	// (get) Token: 0x06006607 RID: 26119 RVA: 0x0019E44C File Offset: 0x0019C64C
	// (set) Token: 0x06006608 RID: 26120 RVA: 0x0019E46A File Offset: 0x0019C66A
	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: 0x17002300 RID: 8960
	// (get) Token: 0x06006609 RID: 26121 RVA: 0x0019E47C File Offset: 0x0019C67C
	// (set) Token: 0x0600660A RID: 26122 RVA: 0x0019E49A File Offset: 0x0019C69A
	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: 0x17002301 RID: 8961
	// (get) Token: 0x0600660B RID: 26123 RVA: 0x0019E4AC File Offset: 0x0019C6AC
	// (set) Token: 0x0600660C RID: 26124 RVA: 0x0019E4CA File Offset: 0x0019C6CA
	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: 0x17002302 RID: 8962
	// (get) Token: 0x0600660D RID: 26125 RVA: 0x0019E4DC File Offset: 0x0019C6DC
	// (set) Token: 0x0600660E RID: 26126 RVA: 0x0019E4FA File Offset: 0x0019C6FA
	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: 0x17002303 RID: 8963
	// (get) Token: 0x0600660F RID: 26127 RVA: 0x0019E50C File Offset: 0x0019C70C
	// (set) Token: 0x06006610 RID: 26128 RVA: 0x0019E52A File Offset: 0x0019C72A
	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: 0x17002304 RID: 8964
	// (get) Token: 0x06006611 RID: 26129 RVA: 0x0019E53C File Offset: 0x0019C73C
	// (set) Token: 0x06006612 RID: 26130 RVA: 0x0019E55A File Offset: 0x0019C75A
	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: 0x04004343 RID: 17219
	private static readonly IntPtr NativeFieldInfoPtr_controllable;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	// Token: 0x04004384 RID: 17284
	private static readonly IntPtr NativeMethodInfoPtr_get_AimReadyWight_Public_get_Single_0;

	// Token: 0x04004385 RID: 17285
	private static readonly IntPtr NativeMethodInfoPtr_get_AimWight_Public_get_Single_0;

	// Token: 0x04004386 RID: 17286
	private static readonly IntPtr NativeMethodInfoPtr_get_HoldingShot_Public_get_Single_0;

	// Token: 0x04004387 RID: 17287
	private static readonly IntPtr NativeMethodInfoPtr_set_HoldingShot_Public_set_Void_Single_0;

	// Token: 0x04004388 RID: 17288
	private static readonly IntPtr NativeMethodInfoPtr_get_HPRecovery_Public_get_Single_0;

	// Token: 0x04004389 RID: 17289
	private static readonly IntPtr NativeMethodInfoPtr_get_MPRecovery_Public_get_Single_0;

	// Token: 0x0400438A RID: 17290
	private static readonly IntPtr NativeMethodInfoPtr_get_MPRecoveryExternal_Public_get_Single_0;

	// Token: 0x0400438B RID: 17291
	private static readonly IntPtr NativeMethodInfoPtr_get_MagicLockTargets_Public_get_Il2CppReferenceArray_1_Transform_0;

	// Token: 0x0400438C RID: 17292
	private static readonly IntPtr NativeMethodInfoPtr_get_HasMagicLockTargets_Public_get_Boolean_0;

	// Token: 0x0400438D RID: 17293
	private static readonly IntPtr NativeMethodInfoPtr_get_StaminaLossDodge_Public_get_Single_0;

	// Token: 0x0400438E RID: 17294
	private static readonly IntPtr NativeMethodInfoPtr_get_StaminaLossDash_Public_get_Single_0;

	// Token: 0x0400438F RID: 17295
	private static readonly IntPtr NativeMethodInfoPtr_get_StaminaLossFall_Public_get_Single_0;

	// Token: 0x04004390 RID: 17296
	private static readonly IntPtr NativeMethodInfoPtr_get_StaminaLossJump_Public_get_Single_0;

	// Token: 0x04004391 RID: 17297
	private static readonly IntPtr NativeMethodInfoPtr_get_AbsorbTimer_Public_get_Single_0;

	// Token: 0x04004392 RID: 17298
	private static readonly IntPtr NativeMethodInfoPtr_get_AbsorbCDTimer_Public_get_Single_0;

	// Token: 0x04004393 RID: 17299
	private static readonly IntPtr NativeMethodInfoPtr_get_AbsorbStatusTimer_Public_get_Single_0;

	// Token: 0x04004394 RID: 17300
	private static readonly IntPtr NativeMethodInfoPtr_get_IsSlip_Public_get_Boolean_0;

	// Token: 0x04004395 RID: 17301
	private static readonly IntPtr NativeMethodInfoPtr_get_IsChargeEnable_Public_get_Boolean_0;

	// Token: 0x04004396 RID: 17302
	private static readonly IntPtr NativeMethodInfoPtr_get_DodgeTimer_Public_get_Single_0;

	// Token: 0x04004397 RID: 17303
	private static readonly IntPtr NativeMethodInfoPtr_get_DamageDodgeTimer_Public_get_Single_0;

	// Token: 0x04004398 RID: 17304
	private static readonly IntPtr NativeMethodInfoPtr_get_ShotEffect_Public_get_Boolean_0;

	// Token: 0x04004399 RID: 17305
	private static readonly IntPtr NativeMethodInfoPtr_get_HardBody_Public_get_Boolean_0;

	// Token: 0x0400439A RID: 17306
	private static readonly IntPtr NativeMethodInfoPtr_get_DodgeDamage_Public_get_Boolean_0;

	// Token: 0x0400439B RID: 17307
	private static readonly IntPtr NativeMethodInfoPtr_get_PrayerAttackTimer_Public_get_Single_0;

	// Token: 0x0400439C RID: 17308
	private static readonly IntPtr NativeMethodInfoPtr_get_NextAttack_Public_get_Boolean_0;

	// Token: 0x0400439D RID: 17309
	private static readonly IntPtr NativeMethodInfoPtr_get_NextAirAttack_Public_get_Boolean_0;

	// Token: 0x0400439E RID: 17310
	private static readonly IntPtr NativeMethodInfoPtr_get_AirAttackTimer_Public_get_Single_0;

	// Token: 0x0400439F RID: 17311
	private static readonly IntPtr NativeMethodInfoPtr_get_WaitTime_Public_get_Single_0;

	// Token: 0x040043A0 RID: 17312
	private static readonly IntPtr NativeMethodInfoPtr_get_NoFireWaitTime_Public_get_Single_0;

	// Token: 0x040043A1 RID: 17313
	private static readonly IntPtr NativeMethodInfoPtr_get_AimTime_Public_get_Single_0;

	// Token: 0x040043A2 RID: 17314
	private static readonly IntPtr NativeMethodInfoPtr_get_ShotTime_Public_get_Single_0;

	// Token: 0x040043A3 RID: 17315
	private static readonly IntPtr NativeMethodInfoPtr_get_NextTime_Public_get_Single_0;

	// Token: 0x040043A4 RID: 17316
	private static readonly IntPtr NativeMethodInfoPtr_get_NextEndTime_Public_get_Single_0;

	// Token: 0x040043A5 RID: 17317
	private static readonly IntPtr NativeMethodInfoPtr_UpdateControllable_Public_Void_Boolean_0;

	// Token: 0x040043A6 RID: 17318
	private static readonly IntPtr NativeMethodInfoPtr_UpdateIsDead_Public_Void_Boolean_0;

	// Token: 0x040043A7 RID: 17319
	private static readonly IntPtr NativeMethodInfoPtr_UpdateTimeMembers_Public_Void_Single_0;

	// Token: 0x040043A8 RID: 17320
	private static readonly IntPtr NativeMethodInfoPtr_UpdateMoveSpeed_Public_Void_Single_0;

	// Token: 0x040043A9 RID: 17321
	private static readonly IntPtr NativeMethodInfoPtr_UpdateMoveDirection_Public_Void_Vector3_0;

	// Token: 0x040043AA RID: 17322
	private static readonly IntPtr NativeMethodInfoPtr_UpdateJumpDirection_Public_Void_0;

	// Token: 0x040043AB RID: 17323
	private static readonly IntPtr NativeMethodInfoPtr_UpdateJumpDirection_Public_Void_Transform_0;

	// Token: 0x040043AC RID: 17324
	private static readonly IntPtr NativeMethodInfoPtr_IncreaseDamagedAirStayTimer_Public_Void_0;

	// Token: 0x040043AD RID: 17325
	private static readonly IntPtr NativeMethodInfoPtr_ResetDamagedAirStayTimer_Public_Void_0;

	// Token: 0x040043AE RID: 17326
	private static readonly IntPtr NativeMethodInfoPtr_UpdateJumpMoveSpeed_Public_Void_Single_0;

	// Token: 0x040043AF RID: 17327
	private static readonly IntPtr NativeMethodInfoPtr_UpdateIsPond_Public_Void_Boolean_0;

	// Token: 0x040043B0 RID: 17328
	private static readonly IntPtr NativeMethodInfoPtr_UpdatePondHeight_Public_Void_Single_0;

	// Token: 0x040043B1 RID: 17329
	private static readonly IntPtr NativeMethodInfoPtr_UpdateIsSky_Public_Void_Boolean_0;

	// Token: 0x040043B2 RID: 17330
	private static readonly IntPtr NativeMethodInfoPtr_UpdateFallTimer_Public_Void_Transform_0;

	// Token: 0x040043B3 RID: 17331
	private static readonly IntPtr NativeMethodInfoPtr_UpdateAimReadyWight_Public_Void_Single_0;

	// Token: 0x040043B4 RID: 17332
	private static readonly IntPtr NativeMethodInfoPtr_UpdateAimWight_Public_Void_Single_0;

	// Token: 0x040043B5 RID: 17333
	private static readonly IntPtr NativeMethodInfoPtr_ResetAimWightValues_Public_Void_0;

	// Token: 0x040043B6 RID: 17334
	private static readonly IntPtr NativeMethodInfoPtr_UpdateHPRecovery_Public_Void_Single_0;

	// Token: 0x040043B7 RID: 17335
	private static readonly IntPtr NativeMethodInfoPtr_UpdateMPRecovery_Public_Void_Single_0;

	// Token: 0x040043B8 RID: 17336
	private static readonly IntPtr NativeMethodInfoPtr_UpdateMPRecoveryExternal_Public_Void_Single_0;

	// Token: 0x040043B9 RID: 17337
	private static readonly IntPtr NativeMethodInfoPtr_UpdateLockTargets_Public_Void_0;

	// Token: 0x040043BA RID: 17338
	private static readonly IntPtr NativeMethodInfoPtr_GetLockTarget_Public_Transform_0;

	// Token: 0x040043BB RID: 17339
	private static readonly IntPtr NativeMethodInfoPtr_DecreaseAbsorbTimers_Public_Void_0;

	// Token: 0x040043BC RID: 17340
	private static readonly IntPtr NativeMethodInfoPtr_ResetAbsorbTimers_Public_Void_0;

	// Token: 0x040043BD RID: 17341
	private static readonly IntPtr NativeMethodInfoPtr_ResetAbsorbStatusTimer_Public_Void_0;

	// Token: 0x040043BE RID: 17342
	private static readonly IntPtr NativeMethodInfoPtr_FillAbsorbTimer_Public_Void_0;

	// Token: 0x040043BF RID: 17343
	private static readonly IntPtr NativeMethodInfoPtr_FillAbsorbCDTimer_Public_Void_0;

	// Token: 0x040043C0 RID: 17344
	private static readonly IntPtr NativeMethodInfoPtr_FillAbsorbStatusTimer_Public_Void_0;

	// Token: 0x040043C1 RID: 17345
	private static readonly IntPtr NativeMethodInfoPtr_UpdateSlipFlag_Public_Void_Boolean_0;

	// Token: 0x040043C2 RID: 17346
	private static readonly IntPtr NativeMethodInfoPtr_UpdateChargeEnabled_Public_Void_Boolean_0;

	// Token: 0x040043C3 RID: 17347
	private static readonly IntPtr NativeMethodInfoPtr_ReverseChargeEnabled_Public_Void_0;

	// Token: 0x040043C4 RID: 17348
	private static readonly IntPtr NativeMethodInfoPtr_DecreaseDodgeTimer_Public_Void_0;

	// Token: 0x040043C5 RID: 17349
	private static readonly IntPtr NativeMethodInfoPtr_UpdateDodgeTimer_Public_Void_Single_0;

	// Token: 0x040043C6 RID: 17350
	private static readonly IntPtr NativeMethodInfoPtr_DecreaseDamageDodgeTimer_Public_Void_0;

	// Token: 0x040043C7 RID: 17351
	private static readonly IntPtr NativeMethodInfoPtr_UpdateDamageDodgeTimer_Public_Void_Single_0;

	// Token: 0x040043C8 RID: 17352
	private static readonly IntPtr NativeMethodInfoPtr_UpdateShotEffect_Public_Void_Boolean_0;

	// Token: 0x040043C9 RID: 17353
	private static readonly IntPtr NativeMethodInfoPtr_UpdateHardBody_Public_Void_Boolean_0;

	// Token: 0x040043CA RID: 17354
	private static readonly IntPtr NativeMethodInfoPtr_UpdateDodgeDamage_Public_Void_Boolean_0;

	// Token: 0x040043CB RID: 17355
	private static readonly IntPtr NativeMethodInfoPtr_FillPrayerAttackTimer_Public_Void_0;

	// Token: 0x040043CC RID: 17356
	private static readonly IntPtr NativeMethodInfoPtr_DecreasePrayerAttackTimer_Public_Void_0;

	// Token: 0x040043CD RID: 17357
	private static readonly IntPtr NativeMethodInfoPtr_UpdateNextAttack_Public_Void_Boolean_0;

	// Token: 0x040043CE RID: 17358
	private static readonly IntPtr NativeMethodInfoPtr_UpdateNextAirAttack_Public_Void_Boolean_0;

	// Token: 0x040043CF RID: 17359
	private static readonly IntPtr NativeMethodInfoPtr_UpdateAirAttackTimer_Public_Void_Single_0;

	// Token: 0x040043D0 RID: 17360
	private static readonly IntPtr NativeMethodInfoPtr_IncreaseAirAttackTimer_Public_Void_Single_0;

	// Token: 0x040043D1 RID: 17361
	private static readonly IntPtr NativeMethodInfoPtr_DecreaseAirAttackTimer_Public_Void_0;

	// Token: 0x040043D2 RID: 17362
	private static readonly IntPtr NativeMethodInfoPtr_UpdateWaitTime_Public_Void_Single_0;

	// Token: 0x040043D3 RID: 17363
	private static readonly IntPtr NativeMethodInfoPtr_DecreaseWaitTime_Public_Void_0;

	// Token: 0x040043D4 RID: 17364
	private static readonly IntPtr NativeMethodInfoPtr_UpdateNoFireWaitTime_Public_Void_Single_0;

	// Token: 0x040043D5 RID: 17365
	private static readonly IntPtr NativeMethodInfoPtr_DecreaseNoFireWaitTime_Public_Void_0;

	// Token: 0x040043D6 RID: 17366
	private static readonly IntPtr NativeMethodInfoPtr_ResetNoFireWaitTime_Public_Void_0;

	// Token: 0x040043D7 RID: 17367
	private static readonly IntPtr NativeMethodInfoPtr_UpdateAimTime_Public_Void_Single_0;

	// Token: 0x040043D8 RID: 17368
	private static readonly IntPtr NativeMethodInfoPtr_UpdateShotTime_Public_Void_Single_0;

	// Token: 0x040043D9 RID: 17369
	private static readonly IntPtr NativeMethodInfoPtr_UpdateNextTime_Public_Void_Single_0;

	// Token: 0x040043DA RID: 17370
	private static readonly IntPtr NativeMethodInfoPtr_UpdateNextEndTime_Public_Void_Single_0;

	// Token: 0x040043DB RID: 17371
	private static readonly IntPtr NativeMethodInfoPtr_ResetAllCharacterValue_Public_Void_0;

	// Token: 0x040043DC RID: 17372
	private static readonly IntPtr NativeMethodInfoPtr_CalculateRepulseTimer_Public_Boolean_Single_0;

	// Token: 0x040043DD RID: 17373
	private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
}