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: 0x02000358 RID: 856
[Serializable]
public class NobetaRuntimeData : Il2CppSystem.Object
{
	// Token: 0x17002541 RID: 9537
	// (get) Token: 0x06006C63 RID: 27747 RVA: 0x001B8660 File Offset: 0x001B6860
	public unsafe bool Controllable
	{
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 6864, RefRangeEnd = 6865, XrefRangeStart = 6864, XrefRangeEnd = 6865, 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: 0x17002542 RID: 9538
	// (get) Token: 0x06006C64 RID: 27748 RVA: 0x001B86B0 File Offset: 0x001B68B0
	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: 0x17002543 RID: 9539
	// (get) Token: 0x06006C65 RID: 27749 RVA: 0x001B8700 File Offset: 0x001B6900
	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: 0x17002544 RID: 9540
	// (get) Token: 0x06006C66 RID: 27750 RVA: 0x001B8750 File Offset: 0x001B6950
	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: 0x17002545 RID: 9541
	// (get) Token: 0x06006C67 RID: 27751 RVA: 0x001B87A0 File Offset: 0x001B69A0
	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: 0x17002546 RID: 9542
	// (get) Token: 0x06006C68 RID: 27752 RVA: 0x001B87F0 File Offset: 0x001B69F0
	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: 0x17002547 RID: 9543
	// (get) Token: 0x06006C69 RID: 27753 RVA: 0x001B8840 File Offset: 0x001B6A40
	public unsafe float RotationSpeed
	{
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 606346, RefRangeEnd = 606347, XrefRangeStart = 606346, XrefRangeEnd = 606346, 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: 0x17002548 RID: 9544
	// (get) Token: 0x06006C6A RID: 27754 RVA: 0x001B8890 File Offset: 0x001B6A90
	public unsafe float MoveSpeedScale
	{
		[CallerCount(11)]
		[CachedScanResults(RefRangeStart = 606347, RefRangeEnd = 606358, XrefRangeStart = 606347, XrefRangeEnd = 606347, 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: 0x17002549 RID: 9545
	// (get) Token: 0x06006C6B RID: 27755 RVA: 0x001B88E0 File Offset: 0x001B6AE0
	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: 0x1700254A RID: 9546
	// (get) Token: 0x06006C6C RID: 27756 RVA: 0x001B8930 File Offset: 0x001B6B30
	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: 0x1700254B RID: 9547
	// (get) Token: 0x06006C6D RID: 27757 RVA: 0x001B8980 File Offset: 0x001B6B80
	public unsafe float JumpForce
	{
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 606358, RefRangeEnd = 606360, XrefRangeStart = 606358, XrefRangeEnd = 606358, 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: 0x1700254C RID: 9548
	// (get) Token: 0x06006C6E RID: 27758 RVA: 0x001B89D0 File Offset: 0x001B6BD0
	public unsafe float Gravity
	{
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 606360, RefRangeEnd = 606361, XrefRangeStart = 606360, XrefRangeEnd = 606360, 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: 0x1700254D RID: 9549
	// (get) Token: 0x06006C6F RID: 27759 RVA: 0x001B8A20 File Offset: 0x001B6C20
	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: 0x1700254E RID: 9550
	// (get) Token: 0x06006C70 RID: 27760 RVA: 0x001B8A70 File Offset: 0x001B6C70
	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: 0x1700254F RID: 9551
	// (get) Token: 0x06006C71 RID: 27761 RVA: 0x001B8AC0 File Offset: 0x001B6CC0
	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: 0x17002550 RID: 9552
	// (get) Token: 0x06006C72 RID: 27762 RVA: 0x001B8B10 File Offset: 0x001B6D10
	public unsafe float FallSpeedMax
	{
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 606361, RefRangeEnd = 606362, XrefRangeStart = 606361, XrefRangeEnd = 606361, 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: 0x17002551 RID: 9553
	// (get) Token: 0x06006C73 RID: 27763 RVA: 0x001B8B60 File Offset: 0x001B6D60
	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: 0x17002552 RID: 9554
	// (get) Token: 0x06006C74 RID: 27764 RVA: 0x001B8BB0 File Offset: 0x001B6DB0
	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: 0x17002553 RID: 9555
	// (get) Token: 0x06006C75 RID: 27765 RVA: 0x001B8C00 File Offset: 0x001B6E00
	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: 0x17002554 RID: 9556
	// (get) Token: 0x06006C76 RID: 27766 RVA: 0x001B8C50 File Offset: 0x001B6E50
	// (set) Token: 0x06006C77 RID: 27767 RVA: 0x001B8CA0 File Offset: 0x001B6EA0
	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: 0x17002555 RID: 9557
	// (get) Token: 0x06006C78 RID: 27768 RVA: 0x001B8CF4 File Offset: 0x001B6EF4
	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: 0x17002556 RID: 9558
	// (get) Token: 0x06006C79 RID: 27769 RVA: 0x001B8D44 File Offset: 0x001B6F44
	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: 0x17002557 RID: 9559
	// (get) Token: 0x06006C7A RID: 27770 RVA: 0x001B8D94 File Offset: 0x001B6F94
	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: 0x17002558 RID: 9560
	// (get) Token: 0x06006C7B RID: 27771 RVA: 0x001B8DE4 File Offset: 0x001B6FE4
	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: 0x17002559 RID: 9561
	// (get) Token: 0x06006C7C RID: 27772 RVA: 0x001B8E3C File Offset: 0x001B703C
	public unsafe bool HasMagicLockTargets
	{
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 606362, RefRangeEnd = 606364, XrefRangeStart = 606362, XrefRangeEnd = 606362, 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: 0x1700255A RID: 9562
	// (get) Token: 0x06006C7D RID: 27773 RVA: 0x001B8E8C File Offset: 0x001B708C
	public unsafe float StaminaLossDodge
	{
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 606364, RefRangeEnd = 606366, XrefRangeStart = 606364, XrefRangeEnd = 606364, 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: 0x1700255B RID: 9563
	// (get) Token: 0x06006C7E RID: 27774 RVA: 0x001B8EDC File Offset: 0x001B70DC
	public unsafe float StaminaLossDash
	{
		[CallerCount(11)]
		[CachedScanResults(RefRangeStart = 606347, RefRangeEnd = 606358, XrefRangeStart = 606347, XrefRangeEnd = 606358, 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: 0x1700255C RID: 9564
	// (get) Token: 0x06006C7F RID: 27775 RVA: 0x001B8F2C File Offset: 0x001B712C
	public unsafe float StaminaLossFall
	{
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 606366, RefRangeEnd = 606367, XrefRangeStart = 606366, XrefRangeEnd = 606366, 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: 0x1700255D RID: 9565
	// (get) Token: 0x06006C80 RID: 27776 RVA: 0x001B8F7C File Offset: 0x001B717C
	public unsafe float StaminaLossJump
	{
		[CallerCount(11)]
		[CachedScanResults(RefRangeStart = 606347, RefRangeEnd = 606358, XrefRangeStart = 606347, XrefRangeEnd = 606358, 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: 0x1700255E RID: 9566
	// (get) Token: 0x06006C81 RID: 27777 RVA: 0x001B8FCC File Offset: 0x001B71CC
	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: 0x1700255F RID: 9567
	// (get) Token: 0x06006C82 RID: 27778 RVA: 0x001B901C File Offset: 0x001B721C
	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: 0x17002560 RID: 9568
	// (get) Token: 0x06006C83 RID: 27779 RVA: 0x001B906C File Offset: 0x001B726C
	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: 0x17002561 RID: 9569
	// (get) Token: 0x06006C84 RID: 27780 RVA: 0x001B90BC File Offset: 0x001B72BC
	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: 0x17002562 RID: 9570
	// (get) Token: 0x06006C85 RID: 27781 RVA: 0x001B910C File Offset: 0x001B730C
	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: 0x17002563 RID: 9571
	// (get) Token: 0x06006C86 RID: 27782 RVA: 0x001B915C File Offset: 0x001B735C
	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: 0x17002564 RID: 9572
	// (get) Token: 0x06006C87 RID: 27783 RVA: 0x001B91AC File Offset: 0x001B73AC
	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: 0x17002565 RID: 9573
	// (get) Token: 0x06006C88 RID: 27784 RVA: 0x001B91FC File Offset: 0x001B73FC
	public unsafe bool ShotEffect
	{
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 24551, RefRangeEnd = 24552, XrefRangeStart = 24551, XrefRangeEnd = 24552, 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: 0x17002566 RID: 9574
	// (get) Token: 0x06006C89 RID: 27785 RVA: 0x001B924C File Offset: 0x001B744C
	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: 0x17002567 RID: 9575
	// (get) Token: 0x06006C8A RID: 27786 RVA: 0x001B929C File Offset: 0x001B749C
	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: 0x17002568 RID: 9576
	// (get) Token: 0x06006C8B RID: 27787 RVA: 0x001B92EC File Offset: 0x001B74EC
	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: 0x17002569 RID: 9577
	// (get) Token: 0x06006C8C RID: 27788 RVA: 0x001B933C File Offset: 0x001B753C
	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: 0x1700256A RID: 9578
	// (get) Token: 0x06006C8D RID: 27789 RVA: 0x001B938C File Offset: 0x001B758C
	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: 0x1700256B RID: 9579
	// (get) Token: 0x06006C8E RID: 27790 RVA: 0x001B93DC File Offset: 0x001B75DC
	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: 0x1700256C RID: 9580
	// (get) Token: 0x06006C8F RID: 27791 RVA: 0x001B942C File Offset: 0x001B762C
	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: 0x1700256D RID: 9581
	// (get) Token: 0x06006C90 RID: 27792 RVA: 0x001B947C File Offset: 0x001B767C
	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: 0x1700256E RID: 9582
	// (get) Token: 0x06006C91 RID: 27793 RVA: 0x001B94CC File Offset: 0x001B76CC
	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: 0x1700256F RID: 9583
	// (get) Token: 0x06006C92 RID: 27794 RVA: 0x001B951C File Offset: 0x001B771C
	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: 0x17002570 RID: 9584
	// (get) Token: 0x06006C93 RID: 27795 RVA: 0x001B956C File Offset: 0x001B776C
	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: 0x17002571 RID: 9585
	// (get) Token: 0x06006C94 RID: 27796 RVA: 0x001B95BC File Offset: 0x001B77BC
	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: 0x06006C95 RID: 27797 RVA: 0x001B960C File Offset: 0x001B780C
	[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: 0x06006C96 RID: 27798 RVA: 0x001B9660 File Offset: 0x001B7860
	[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: 0x06006C97 RID: 27799 RVA: 0x001B96B4 File Offset: 0x001B78B4
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 606371, RefRangeEnd = 606372, XrefRangeStart = 606367, XrefRangeEnd = 606371, 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: 0x06006C98 RID: 27800 RVA: 0x001B9708 File Offset: 0x001B7908
	[CallerCount(4)]
	[CachedScanResults(RefRangeStart = 223847, RefRangeEnd = 223851, XrefRangeStart = 223847, XrefRangeEnd = 223851, 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: 0x06006C99 RID: 27801 RVA: 0x001B975C File Offset: 0x001B795C
	[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: 0x06006C9A RID: 27802 RVA: 0x001B97B0 File Offset: 0x001B79B0
	[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: 0x06006C9B RID: 27803 RVA: 0x001B97F4 File Offset: 0x001B79F4
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 606376, RefRangeEnd = 606377, XrefRangeStart = 606372, XrefRangeEnd = 606376, 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: 0x06006C9C RID: 27804 RVA: 0x001B9850 File Offset: 0x001B7A50
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 606377, RefRangeEnd = 606378, XrefRangeStart = 606377, XrefRangeEnd = 606377, 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: 0x06006C9D RID: 27805 RVA: 0x001B9894 File Offset: 0x001B7A94
	[CallerCount(5)]
	[CachedScanResults(RefRangeStart = 606378, RefRangeEnd = 606383, XrefRangeStart = 606378, XrefRangeEnd = 606378, 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: 0x06006C9E RID: 27806 RVA: 0x001B98D8 File Offset: 0x001B7AD8
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 225923, RefRangeEnd = 225924, XrefRangeStart = 225923, XrefRangeEnd = 225924, 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: 0x06006C9F RID: 27807 RVA: 0x001B992C File Offset: 0x001B7B2C
	[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: 0x06006CA0 RID: 27808 RVA: 0x001B9980 File Offset: 0x001B7B80
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 225973, RefRangeEnd = 225974, XrefRangeStart = 225973, XrefRangeEnd = 225974, 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: 0x06006CA1 RID: 27809 RVA: 0x001B99D4 File Offset: 0x001B7BD4
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 606383, RefRangeEnd = 606384, XrefRangeStart = 606383, XrefRangeEnd = 606383, 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: 0x06006CA2 RID: 27810 RVA: 0x001B9A28 File Offset: 0x001B7C28
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 606387, RefRangeEnd = 606388, XrefRangeStart = 606384, XrefRangeEnd = 606387, 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: 0x06006CA3 RID: 27811 RVA: 0x001B9A84 File Offset: 0x001B7C84
	[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: 0x06006CA4 RID: 27812 RVA: 0x001B9AD8 File Offset: 0x001B7CD8
	[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: 0x06006CA5 RID: 27813 RVA: 0x001B9B2C File Offset: 0x001B7D2C
	[CallerCount(9)]
	[CachedScanResults(RefRangeStart = 606388, RefRangeEnd = 606397, XrefRangeStart = 606388, XrefRangeEnd = 606388, 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: 0x06006CA6 RID: 27814 RVA: 0x001B9B70 File Offset: 0x001B7D70
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 606397, RefRangeEnd = 606399, XrefRangeStart = 606397, XrefRangeEnd = 606397, 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: 0x06006CA7 RID: 27815 RVA: 0x001B9BC4 File Offset: 0x001B7DC4
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 606399, RefRangeEnd = 606401, XrefRangeStart = 606399, XrefRangeEnd = 606399, 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: 0x06006CA8 RID: 27816 RVA: 0x001B9C18 File Offset: 0x001B7E18
	[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: 0x06006CA9 RID: 27817 RVA: 0x001B9C6C File Offset: 0x001B7E6C
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 606408, RefRangeEnd = 606410, XrefRangeStart = 606401, XrefRangeEnd = 606408, 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: 0x06006CAA RID: 27818 RVA: 0x001B9CB0 File Offset: 0x001B7EB0
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 606410, RefRangeEnd = 606412, XrefRangeStart = 606410, XrefRangeEnd = 606410, 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: 0x06006CAB RID: 27819 RVA: 0x001B9D08 File Offset: 0x001B7F08
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 606415, RefRangeEnd = 606416, XrefRangeStart = 606412, XrefRangeEnd = 606415, 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: 0x06006CAC RID: 27820 RVA: 0x001B9D4C File Offset: 0x001B7F4C
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 606416, RefRangeEnd = 606418, XrefRangeStart = 606416, XrefRangeEnd = 606416, 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: 0x06006CAD RID: 27821 RVA: 0x001B9D90 File Offset: 0x001B7F90
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 606418, RefRangeEnd = 606419, XrefRangeStart = 606418, XrefRangeEnd = 606418, 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: 0x06006CAE RID: 27822 RVA: 0x001B9DD4 File Offset: 0x001B7FD4
	[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: 0x06006CAF RID: 27823 RVA: 0x001B9E18 File Offset: 0x001B8018
	[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: 0x06006CB0 RID: 27824 RVA: 0x001B9E5C File Offset: 0x001B805C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 606419, RefRangeEnd = 606420, XrefRangeStart = 606419, XrefRangeEnd = 606419, 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: 0x06006CB1 RID: 27825 RVA: 0x001B9EA0 File Offset: 0x001B80A0
	[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: 0x06006CB2 RID: 27826 RVA: 0x001B9EF4 File Offset: 0x001B80F4
	[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: 0x06006CB3 RID: 27827 RVA: 0x001B9F48 File Offset: 0x001B8148
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 606420, RefRangeEnd = 606421, XrefRangeStart = 606420, XrefRangeEnd = 606420, 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: 0x06006CB4 RID: 27828 RVA: 0x001B9F8C File Offset: 0x001B818C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 606422, RefRangeEnd = 606423, XrefRangeStart = 606421, XrefRangeEnd = 606422, 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: 0x06006CB5 RID: 27829 RVA: 0x001B9FD0 File Offset: 0x001B81D0
	[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: 0x06006CB6 RID: 27830 RVA: 0x001BA024 File Offset: 0x001B8224
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 606428, RefRangeEnd = 606429, XrefRangeStart = 606423, XrefRangeEnd = 606428, 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: 0x06006CB7 RID: 27831 RVA: 0x001BA068 File Offset: 0x001B8268
	[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: 0x06006CB8 RID: 27832 RVA: 0x001BA0BC File Offset: 0x001B82BC
	[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: 0x06006CB9 RID: 27833 RVA: 0x001BA110 File Offset: 0x001B8310
	[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: 0x06006CBA RID: 27834 RVA: 0x001BA164 File Offset: 0x001B8364
	[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: 0x06006CBB RID: 27835 RVA: 0x001BA1B8 File Offset: 0x001B83B8
	[CallerCount(3)]
	[CachedScanResults(RefRangeStart = 606429, RefRangeEnd = 606432, XrefRangeStart = 606429, XrefRangeEnd = 606429, 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: 0x06006CBC RID: 27836 RVA: 0x001BA1FC File Offset: 0x001B83FC
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 606433, RefRangeEnd = 606434, XrefRangeStart = 606432, XrefRangeEnd = 606433, 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: 0x06006CBD RID: 27837 RVA: 0x001BA240 File Offset: 0x001B8440
	[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: 0x06006CBE RID: 27838 RVA: 0x001BA294 File Offset: 0x001B8494
	[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: 0x06006CBF RID: 27839 RVA: 0x001BA2E8 File Offset: 0x001B84E8
	[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: 0x06006CC0 RID: 27840 RVA: 0x001BA33C File Offset: 0x001B853C
	[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: 0x06006CC1 RID: 27841 RVA: 0x001BA390 File Offset: 0x001B8590
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 606435, RefRangeEnd = 606436, XrefRangeStart = 606434, XrefRangeEnd = 606435, 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: 0x06006CC2 RID: 27842 RVA: 0x001BA3D4 File Offset: 0x001B85D4
	[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: 0x06006CC3 RID: 27843 RVA: 0x001BA428 File Offset: 0x001B8628
	[CallerCount(24)]
	[CachedScanResults(RefRangeStart = 606437, RefRangeEnd = 606461, XrefRangeStart = 606436, XrefRangeEnd = 606437, 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: 0x06006CC4 RID: 27844 RVA: 0x001BA46C File Offset: 0x001B866C
	[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: 0x06006CC5 RID: 27845 RVA: 0x001BA4C0 File Offset: 0x001B86C0
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 606462, RefRangeEnd = 606464, XrefRangeStart = 606461, XrefRangeEnd = 606462, 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: 0x06006CC6 RID: 27846 RVA: 0x001BA504 File Offset: 0x001B8704
	[CallerCount(5)]
	[CachedScanResults(RefRangeStart = 606464, RefRangeEnd = 606469, XrefRangeStart = 606464, XrefRangeEnd = 606464, 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: 0x06006CC7 RID: 27847 RVA: 0x001BA548 File Offset: 0x001B8748
	[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: 0x06006CC8 RID: 27848 RVA: 0x001BA59C File Offset: 0x001B879C
	[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: 0x06006CC9 RID: 27849 RVA: 0x001BA5F0 File Offset: 0x001B87F0
	[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: 0x06006CCA RID: 27850 RVA: 0x001BA644 File Offset: 0x001B8844
	[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: 0x06006CCB RID: 27851 RVA: 0x001BA698 File Offset: 0x001B8898
	[CallerCount(5)]
	[CachedScanResults(RefRangeStart = 606378, RefRangeEnd = 606383, XrefRangeStart = 606378, XrefRangeEnd = 606383, 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: 0x06006CCC RID: 27852 RVA: 0x001BA6DC File Offset: 0x001B88DC
	[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: 0x06006CCD RID: 27853 RVA: 0x001BA740 File Offset: 0x001B8940
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 606469, XrefRangeEnd = 606471, 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: 0x06006CCE RID: 27854 RVA: 0x001BA78C File Offset: 0x001B898C
	// 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, 100671363);
		NobetaRuntimeData.NativeMethodInfoPtr_get_IsDead_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671364);
		NobetaRuntimeData.NativeMethodInfoPtr_get_DeltaTime_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671365);
		NobetaRuntimeData.NativeMethodInfoPtr_get_TimeScale_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671366);
		NobetaRuntimeData.NativeMethodInfoPtr_get_MoveSpeed_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671367);
		NobetaRuntimeData.NativeMethodInfoPtr_get_JumpMoveSpeed_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671368);
		NobetaRuntimeData.NativeMethodInfoPtr_get_RotationSpeed_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671369);
		NobetaRuntimeData.NativeMethodInfoPtr_get_MoveSpeedScale_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671370);
		NobetaRuntimeData.NativeMethodInfoPtr_get_MoveDirection_Public_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671371);
		NobetaRuntimeData.NativeMethodInfoPtr_get_JumpDirection_Public_get_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671372);
		NobetaRuntimeData.NativeMethodInfoPtr_get_JumpForce_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671373);
		NobetaRuntimeData.NativeMethodInfoPtr_get_Gravity_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671374);
		NobetaRuntimeData.NativeMethodInfoPtr_get_IsPond_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671375);
		NobetaRuntimeData.NativeMethodInfoPtr_get_PondHeight_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671376);
		NobetaRuntimeData.NativeMethodInfoPtr_get_IsSky_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671377);
		NobetaRuntimeData.NativeMethodInfoPtr_get_FallSpeedMax_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671378);
		NobetaRuntimeData.NativeMethodInfoPtr_get_FallTimer_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671379);
		NobetaRuntimeData.NativeMethodInfoPtr_get_AimReadyWight_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671380);
		NobetaRuntimeData.NativeMethodInfoPtr_get_AimWight_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671381);
		NobetaRuntimeData.NativeMethodInfoPtr_get_HoldingShot_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671382);
		NobetaRuntimeData.NativeMethodInfoPtr_set_HoldingShot_Public_set_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671383);
		NobetaRuntimeData.NativeMethodInfoPtr_get_HPRecovery_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671384);
		NobetaRuntimeData.NativeMethodInfoPtr_get_MPRecovery_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671385);
		NobetaRuntimeData.NativeMethodInfoPtr_get_MPRecoveryExternal_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671386);
		NobetaRuntimeData.NativeMethodInfoPtr_get_MagicLockTargets_Public_get_Il2CppReferenceArray_1_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671387);
		NobetaRuntimeData.NativeMethodInfoPtr_get_HasMagicLockTargets_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671388);
		NobetaRuntimeData.NativeMethodInfoPtr_get_StaminaLossDodge_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671389);
		NobetaRuntimeData.NativeMethodInfoPtr_get_StaminaLossDash_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671390);
		NobetaRuntimeData.NativeMethodInfoPtr_get_StaminaLossFall_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671391);
		NobetaRuntimeData.NativeMethodInfoPtr_get_StaminaLossJump_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671392);
		NobetaRuntimeData.NativeMethodInfoPtr_get_AbsorbTimer_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671393);
		NobetaRuntimeData.NativeMethodInfoPtr_get_AbsorbCDTimer_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671394);
		NobetaRuntimeData.NativeMethodInfoPtr_get_AbsorbStatusTimer_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671395);
		NobetaRuntimeData.NativeMethodInfoPtr_get_IsSlip_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671396);
		NobetaRuntimeData.NativeMethodInfoPtr_get_IsChargeEnable_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671397);
		NobetaRuntimeData.NativeMethodInfoPtr_get_DodgeTimer_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671398);
		NobetaRuntimeData.NativeMethodInfoPtr_get_DamageDodgeTimer_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671399);
		NobetaRuntimeData.NativeMethodInfoPtr_get_ShotEffect_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671400);
		NobetaRuntimeData.NativeMethodInfoPtr_get_HardBody_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671401);
		NobetaRuntimeData.NativeMethodInfoPtr_get_DodgeDamage_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671402);
		NobetaRuntimeData.NativeMethodInfoPtr_get_PrayerAttackTimer_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671403);
		NobetaRuntimeData.NativeMethodInfoPtr_get_NextAttack_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671404);
		NobetaRuntimeData.NativeMethodInfoPtr_get_NextAirAttack_Public_get_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671405);
		NobetaRuntimeData.NativeMethodInfoPtr_get_AirAttackTimer_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671406);
		NobetaRuntimeData.NativeMethodInfoPtr_get_WaitTime_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671407);
		NobetaRuntimeData.NativeMethodInfoPtr_get_NoFireWaitTime_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671408);
		NobetaRuntimeData.NativeMethodInfoPtr_get_AimTime_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671409);
		NobetaRuntimeData.NativeMethodInfoPtr_get_ShotTime_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671410);
		NobetaRuntimeData.NativeMethodInfoPtr_get_NextTime_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671411);
		NobetaRuntimeData.NativeMethodInfoPtr_get_NextEndTime_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671412);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateControllable_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671413);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateIsDead_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671414);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateTimeMembers_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671415);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateMoveSpeed_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671416);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateMoveDirection_Public_Void_Vector3_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671417);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateJumpDirection_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671418);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateJumpDirection_Public_Void_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671419);
		NobetaRuntimeData.NativeMethodInfoPtr_IncreaseDamagedAirStayTimer_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671420);
		NobetaRuntimeData.NativeMethodInfoPtr_ResetDamagedAirStayTimer_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671421);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateJumpMoveSpeed_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671422);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateIsPond_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671423);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdatePondHeight_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671424);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateIsSky_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671425);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateFallTimer_Public_Void_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671426);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateAimReadyWight_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671427);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateAimWight_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671428);
		NobetaRuntimeData.NativeMethodInfoPtr_ResetAimWightValues_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671429);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateHPRecovery_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671430);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateMPRecovery_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671431);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateMPRecoveryExternal_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671432);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateLockTargets_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671433);
		NobetaRuntimeData.NativeMethodInfoPtr_GetLockTarget_Public_Transform_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671434);
		NobetaRuntimeData.NativeMethodInfoPtr_DecreaseAbsorbTimers_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671435);
		NobetaRuntimeData.NativeMethodInfoPtr_ResetAbsorbTimers_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671436);
		NobetaRuntimeData.NativeMethodInfoPtr_ResetAbsorbStatusTimer_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671437);
		NobetaRuntimeData.NativeMethodInfoPtr_FillAbsorbTimer_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671438);
		NobetaRuntimeData.NativeMethodInfoPtr_FillAbsorbCDTimer_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671439);
		NobetaRuntimeData.NativeMethodInfoPtr_FillAbsorbStatusTimer_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671440);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateSlipFlag_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671441);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateChargeEnabled_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671442);
		NobetaRuntimeData.NativeMethodInfoPtr_ReverseChargeEnabled_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671443);
		NobetaRuntimeData.NativeMethodInfoPtr_DecreaseDodgeTimer_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671444);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateDodgeTimer_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671445);
		NobetaRuntimeData.NativeMethodInfoPtr_DecreaseDamageDodgeTimer_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671446);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateDamageDodgeTimer_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671447);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateShotEffect_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671448);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateHardBody_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671449);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateDodgeDamage_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671450);
		NobetaRuntimeData.NativeMethodInfoPtr_FillPrayerAttackTimer_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671451);
		NobetaRuntimeData.NativeMethodInfoPtr_DecreasePrayerAttackTimer_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671452);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateNextAttack_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671453);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateNextAirAttack_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671454);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateAirAttackTimer_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671455);
		NobetaRuntimeData.NativeMethodInfoPtr_IncreaseAirAttackTimer_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671456);
		NobetaRuntimeData.NativeMethodInfoPtr_DecreaseAirAttackTimer_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671457);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateWaitTime_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671458);
		NobetaRuntimeData.NativeMethodInfoPtr_DecreaseWaitTime_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671459);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateNoFireWaitTime_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671460);
		NobetaRuntimeData.NativeMethodInfoPtr_DecreaseNoFireWaitTime_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671461);
		NobetaRuntimeData.NativeMethodInfoPtr_ResetNoFireWaitTime_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671462);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateAimTime_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671463);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateShotTime_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671464);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateNextTime_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671465);
		NobetaRuntimeData.NativeMethodInfoPtr_UpdateNextEndTime_Public_Void_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671466);
		NobetaRuntimeData.NativeMethodInfoPtr_ResetAllCharacterValue_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671467);
		NobetaRuntimeData.NativeMethodInfoPtr_CalculateRepulseTimer_Public_Boolean_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671468);
		NobetaRuntimeData.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<NobetaRuntimeData>.NativeClassPtr, 100671469);
	}

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

	// Token: 0x17002511 RID: 9489
	// (get) Token: 0x06006CD0 RID: 27856 RVA: 0x001BB3D8 File Offset: 0x001B95D8
	// (set) Token: 0x06006CD1 RID: 27857 RVA: 0x001BB400 File Offset: 0x001B9600
	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: 0x17002512 RID: 9490
	// (get) Token: 0x06006CD2 RID: 27858 RVA: 0x001BB424 File Offset: 0x001B9624
	// (set) Token: 0x06006CD3 RID: 27859 RVA: 0x001BB44C File Offset: 0x001B964C
	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: 0x17002513 RID: 9491
	// (get) Token: 0x06006CD4 RID: 27860 RVA: 0x001BB470 File Offset: 0x001B9670
	// (set) Token: 0x06006CD5 RID: 27861 RVA: 0x001BB498 File Offset: 0x001B9698
	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: 0x17002514 RID: 9492
	// (get) Token: 0x06006CD6 RID: 27862 RVA: 0x001BB4BC File Offset: 0x001B96BC
	// (set) Token: 0x06006CD7 RID: 27863 RVA: 0x001BB4E4 File Offset: 0x001B96E4
	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: 0x17002515 RID: 9493
	// (get) Token: 0x06006CD8 RID: 27864 RVA: 0x001BB508 File Offset: 0x001B9708
	// (set) Token: 0x06006CD9 RID: 27865 RVA: 0x001BB530 File Offset: 0x001B9730
	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: 0x17002516 RID: 9494
	// (get) Token: 0x06006CDA RID: 27866 RVA: 0x001BB554 File Offset: 0x001B9754
	// (set) Token: 0x06006CDB RID: 27867 RVA: 0x001BB57C File Offset: 0x001B977C
	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: 0x17002517 RID: 9495
	// (get) Token: 0x06006CDC RID: 27868 RVA: 0x001BB5A0 File Offset: 0x001B97A0
	// (set) Token: 0x06006CDD RID: 27869 RVA: 0x001BB5C8 File Offset: 0x001B97C8
	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: 0x17002518 RID: 9496
	// (get) Token: 0x06006CDE RID: 27870 RVA: 0x001BB5EC File Offset: 0x001B97EC
	// (set) Token: 0x06006CDF RID: 27871 RVA: 0x001BB614 File Offset: 0x001B9814
	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: 0x17002519 RID: 9497
	// (get) Token: 0x06006CE0 RID: 27872 RVA: 0x001BB638 File Offset: 0x001B9838
	// (set) Token: 0x06006CE1 RID: 27873 RVA: 0x001BB660 File Offset: 0x001B9860
	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: 0x1700251A RID: 9498
	// (get) Token: 0x06006CE2 RID: 27874 RVA: 0x001BB684 File Offset: 0x001B9884
	// (set) Token: 0x06006CE3 RID: 27875 RVA: 0x001BB6AC File Offset: 0x001B98AC
	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: 0x1700251B RID: 9499
	// (get) Token: 0x06006CE4 RID: 27876 RVA: 0x001BB6D0 File Offset: 0x001B98D0
	// (set) Token: 0x06006CE5 RID: 27877 RVA: 0x001BB6F8 File Offset: 0x001B98F8
	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: 0x1700251C RID: 9500
	// (get) Token: 0x06006CE6 RID: 27878 RVA: 0x001BB71C File Offset: 0x001B991C
	// (set) Token: 0x06006CE7 RID: 27879 RVA: 0x001BB744 File Offset: 0x001B9944
	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: 0x1700251D RID: 9501
	// (get) Token: 0x06006CE8 RID: 27880 RVA: 0x001BB768 File Offset: 0x001B9968
	// (set) Token: 0x06006CE9 RID: 27881 RVA: 0x001BB790 File Offset: 0x001B9990
	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: 0x1700251E RID: 9502
	// (get) Token: 0x06006CEA RID: 27882 RVA: 0x001BB7B4 File Offset: 0x001B99B4
	// (set) Token: 0x06006CEB RID: 27883 RVA: 0x001BB7DC File Offset: 0x001B99DC
	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: 0x1700251F RID: 9503
	// (get) Token: 0x06006CEC RID: 27884 RVA: 0x001BB800 File Offset: 0x001B9A00
	// (set) Token: 0x06006CED RID: 27885 RVA: 0x001BB828 File Offset: 0x001B9A28
	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: 0x17002520 RID: 9504
	// (get) Token: 0x06006CEE RID: 27886 RVA: 0x001BB84C File Offset: 0x001B9A4C
	// (set) Token: 0x06006CEF RID: 27887 RVA: 0x001BB874 File Offset: 0x001B9A74
	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: 0x17002521 RID: 9505
	// (get) Token: 0x06006CF0 RID: 27888 RVA: 0x001BB898 File Offset: 0x001B9A98
	// (set) Token: 0x06006CF1 RID: 27889 RVA: 0x001BB8C0 File Offset: 0x001B9AC0
	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: 0x17002522 RID: 9506
	// (get) Token: 0x06006CF2 RID: 27890 RVA: 0x001BB8E4 File Offset: 0x001B9AE4
	// (set) Token: 0x06006CF3 RID: 27891 RVA: 0x001BB90C File Offset: 0x001B9B0C
	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: 0x17002523 RID: 9507
	// (get) Token: 0x06006CF4 RID: 27892 RVA: 0x001BB930 File Offset: 0x001B9B30
	// (set) Token: 0x06006CF5 RID: 27893 RVA: 0x001BB958 File Offset: 0x001B9B58
	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: 0x17002524 RID: 9508
	// (get) Token: 0x06006CF6 RID: 27894 RVA: 0x001BB97C File Offset: 0x001B9B7C
	// (set) Token: 0x06006CF7 RID: 27895 RVA: 0x001BB9A4 File Offset: 0x001B9BA4
	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: 0x17002525 RID: 9509
	// (get) Token: 0x06006CF8 RID: 27896 RVA: 0x001BB9C8 File Offset: 0x001B9BC8
	// (set) Token: 0x06006CF9 RID: 27897 RVA: 0x001BB9FC File Offset: 0x001B9BFC
	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: 0x17002526 RID: 9510
	// (get) Token: 0x06006CFA RID: 27898 RVA: 0x001BBA24 File Offset: 0x001B9C24
	// (set) Token: 0x06006CFB RID: 27899 RVA: 0x001BBA4C File Offset: 0x001B9C4C
	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: 0x17002527 RID: 9511
	// (get) Token: 0x06006CFC RID: 27900 RVA: 0x001BBA70 File Offset: 0x001B9C70
	// (set) Token: 0x06006CFD RID: 27901 RVA: 0x001BBA98 File Offset: 0x001B9C98
	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: 0x17002528 RID: 9512
	// (get) Token: 0x06006CFE RID: 27902 RVA: 0x001BBABC File Offset: 0x001B9CBC
	// (set) Token: 0x06006CFF RID: 27903 RVA: 0x001BBAE4 File Offset: 0x001B9CE4
	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: 0x17002529 RID: 9513
	// (get) Token: 0x06006D00 RID: 27904 RVA: 0x001BBB08 File Offset: 0x001B9D08
	// (set) Token: 0x06006D01 RID: 27905 RVA: 0x001BBB30 File Offset: 0x001B9D30
	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: 0x1700252A RID: 9514
	// (get) Token: 0x06006D02 RID: 27906 RVA: 0x001BBB54 File Offset: 0x001B9D54
	// (set) Token: 0x06006D03 RID: 27907 RVA: 0x001BBB7C File Offset: 0x001B9D7C
	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: 0x1700252B RID: 9515
	// (get) Token: 0x06006D04 RID: 27908 RVA: 0x001BBBA0 File Offset: 0x001B9DA0
	// (set) Token: 0x06006D05 RID: 27909 RVA: 0x001BBBC8 File Offset: 0x001B9DC8
	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: 0x1700252C RID: 9516
	// (get) Token: 0x06006D06 RID: 27910 RVA: 0x001BBBEC File Offset: 0x001B9DEC
	// (set) Token: 0x06006D07 RID: 27911 RVA: 0x001BBC14 File Offset: 0x001B9E14
	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: 0x1700252D RID: 9517
	// (get) Token: 0x06006D08 RID: 27912 RVA: 0x001BBC38 File Offset: 0x001B9E38
	// (set) Token: 0x06006D09 RID: 27913 RVA: 0x001BBC60 File Offset: 0x001B9E60
	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: 0x1700252E RID: 9518
	// (get) Token: 0x06006D0A RID: 27914 RVA: 0x001BBC84 File Offset: 0x001B9E84
	// (set) Token: 0x06006D0B RID: 27915 RVA: 0x001BBCAC File Offset: 0x001B9EAC
	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: 0x1700252F RID: 9519
	// (get) Token: 0x06006D0C RID: 27916 RVA: 0x001BBCD0 File Offset: 0x001B9ED0
	// (set) Token: 0x06006D0D RID: 27917 RVA: 0x001BBCF8 File Offset: 0x001B9EF8
	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: 0x17002530 RID: 9520
	// (get) Token: 0x06006D0E RID: 27918 RVA: 0x001BBD1C File Offset: 0x001B9F1C
	// (set) Token: 0x06006D0F RID: 27919 RVA: 0x001BBD44 File Offset: 0x001B9F44
	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: 0x17002531 RID: 9521
	// (get) Token: 0x06006D10 RID: 27920 RVA: 0x001BBD68 File Offset: 0x001B9F68
	// (set) Token: 0x06006D11 RID: 27921 RVA: 0x001BBD90 File Offset: 0x001B9F90
	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: 0x17002532 RID: 9522
	// (get) Token: 0x06006D12 RID: 27922 RVA: 0x001BBDB4 File Offset: 0x001B9FB4
	// (set) Token: 0x06006D13 RID: 27923 RVA: 0x001BBDDC File Offset: 0x001B9FDC
	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: 0x17002533 RID: 9523
	// (get) Token: 0x06006D14 RID: 27924 RVA: 0x001BBE00 File Offset: 0x001BA000
	// (set) Token: 0x06006D15 RID: 27925 RVA: 0x001BBE28 File Offset: 0x001BA028
	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: 0x17002534 RID: 9524
	// (get) Token: 0x06006D16 RID: 27926 RVA: 0x001BBE4C File Offset: 0x001BA04C
	// (set) Token: 0x06006D17 RID: 27927 RVA: 0x001BBE74 File Offset: 0x001BA074
	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: 0x17002535 RID: 9525
	// (get) Token: 0x06006D18 RID: 27928 RVA: 0x001BBE98 File Offset: 0x001BA098
	// (set) Token: 0x06006D19 RID: 27929 RVA: 0x001BBEC0 File Offset: 0x001BA0C0
	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: 0x17002536 RID: 9526
	// (get) Token: 0x06006D1A RID: 27930 RVA: 0x001BBEE4 File Offset: 0x001BA0E4
	// (set) Token: 0x06006D1B RID: 27931 RVA: 0x001BBF0C File Offset: 0x001BA10C
	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: 0x17002537 RID: 9527
	// (get) Token: 0x06006D1C RID: 27932 RVA: 0x001BBF30 File Offset: 0x001BA130
	// (set) Token: 0x06006D1D RID: 27933 RVA: 0x001BBF58 File Offset: 0x001BA158
	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: 0x17002538 RID: 9528
	// (get) Token: 0x06006D1E RID: 27934 RVA: 0x001BBF7C File Offset: 0x001BA17C
	// (set) Token: 0x06006D1F RID: 27935 RVA: 0x001BBFA4 File Offset: 0x001BA1A4
	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: 0x17002539 RID: 9529
	// (get) Token: 0x06006D20 RID: 27936 RVA: 0x001BBFC8 File Offset: 0x001BA1C8
	// (set) Token: 0x06006D21 RID: 27937 RVA: 0x001BBFF0 File Offset: 0x001BA1F0
	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: 0x1700253A RID: 9530
	// (get) Token: 0x06006D22 RID: 27938 RVA: 0x001BC014 File Offset: 0x001BA214
	// (set) Token: 0x06006D23 RID: 27939 RVA: 0x001BC03C File Offset: 0x001BA23C
	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: 0x1700253B RID: 9531
	// (get) Token: 0x06006D24 RID: 27940 RVA: 0x001BC060 File Offset: 0x001BA260
	// (set) Token: 0x06006D25 RID: 27941 RVA: 0x001BC07E File Offset: 0x001BA27E
	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: 0x1700253C RID: 9532
	// (get) Token: 0x06006D26 RID: 27942 RVA: 0x001BC090 File Offset: 0x001BA290
	// (set) Token: 0x06006D27 RID: 27943 RVA: 0x001BC0AE File Offset: 0x001BA2AE
	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: 0x1700253D RID: 9533
	// (get) Token: 0x06006D28 RID: 27944 RVA: 0x001BC0C0 File Offset: 0x001BA2C0
	// (set) Token: 0x06006D29 RID: 27945 RVA: 0x001BC0DE File Offset: 0x001BA2DE
	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: 0x1700253E RID: 9534
	// (get) Token: 0x06006D2A RID: 27946 RVA: 0x001BC0F0 File Offset: 0x001BA2F0
	// (set) Token: 0x06006D2B RID: 27947 RVA: 0x001BC10E File Offset: 0x001BA30E
	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: 0x1700253F RID: 9535
	// (get) Token: 0x06006D2C RID: 27948 RVA: 0x001BC120 File Offset: 0x001BA320
	// (set) Token: 0x06006D2D RID: 27949 RVA: 0x001BC13E File Offset: 0x001BA33E
	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: 0x17002540 RID: 9536
	// (get) Token: 0x06006D2E RID: 27950 RVA: 0x001BC150 File Offset: 0x001BA350
	// (set) Token: 0x06006D2F RID: 27951 RVA: 0x001BC16E File Offset: 0x001BA36E
	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: 0x04004820 RID: 18464
	private static readonly IntPtr NativeFieldInfoPtr_controllable;

	// Token: 0x04004821 RID: 18465
	private static readonly IntPtr NativeFieldInfoPtr_isDead;

	// Token: 0x04004822 RID: 18466
	private static readonly IntPtr NativeFieldInfoPtr_timeScale;

	// Token: 0x04004823 RID: 18467
	private static readonly IntPtr NativeFieldInfoPtr_deltaTime;

	// Token: 0x04004824 RID: 18468
	private static readonly IntPtr NativeFieldInfoPtr_moveSpeed;

	// Token: 0x04004825 RID: 18469
	private static readonly IntPtr NativeFieldInfoPtr_jumpMoveSpeed;

	// Token: 0x04004826 RID: 18470
	private static readonly IntPtr NativeFieldInfoPtr_moveDirection;

	// Token: 0x04004827 RID: 18471
	private static readonly IntPtr NativeFieldInfoPtr_jumpDirection;

	// Token: 0x04004828 RID: 18472
	private static readonly IntPtr NativeFieldInfoPtr_isPond;

	// Token: 0x04004829 RID: 18473
	private static readonly IntPtr NativeFieldInfoPtr_pondHeight;

	// Token: 0x0400482A RID: 18474
	private static readonly IntPtr NativeFieldInfoPtr_isSky;

	// Token: 0x0400482B RID: 18475
	private static readonly IntPtr NativeFieldInfoPtr_damagedAirStayTimer;

	// Token: 0x0400482C RID: 18476
	private static readonly IntPtr NativeFieldInfoPtr_fallTimer;

	// Token: 0x0400482D RID: 18477
	private static readonly IntPtr NativeFieldInfoPtr_previousPosition;

	// Token: 0x0400482E RID: 18478
	private static readonly IntPtr NativeFieldInfoPtr_aimWight;

	// Token: 0x0400482F RID: 18479
	private static readonly IntPtr NativeFieldInfoPtr_aimReadyWight;

	// Token: 0x04004830 RID: 18480
	private static readonly IntPtr NativeFieldInfoPtr_holdingShot;

	// Token: 0x04004831 RID: 18481
	private static readonly IntPtr NativeFieldInfoPtr_hpRecovery;

	// Token: 0x04004832 RID: 18482
	private static readonly IntPtr NativeFieldInfoPtr_mpRecovery;

	// Token: 0x04004833 RID: 18483
	private static readonly IntPtr NativeFieldInfoPtr_mpRecoveryExternal;

	// Token: 0x04004834 RID: 18484
	private static readonly IntPtr NativeFieldInfoPtr_magicLockTargets;

	// Token: 0x04004835 RID: 18485
	private static readonly IntPtr NativeFieldInfoPtr_absorbTimer;

	// Token: 0x04004836 RID: 18486
	private static readonly IntPtr NativeFieldInfoPtr_absorbCDTimer;

	// Token: 0x04004837 RID: 18487
	private static readonly IntPtr NativeFieldInfoPtr_absorbStatusTimer;

	// Token: 0x04004838 RID: 18488
	private static readonly IntPtr NativeFieldInfoPtr_isSlip;

	// Token: 0x04004839 RID: 18489
	private static readonly IntPtr NativeFieldInfoPtr_isChargeEnable;

	// Token: 0x0400483A RID: 18490
	private static readonly IntPtr NativeFieldInfoPtr_dodgeTimer;

	// Token: 0x0400483B RID: 18491
	private static readonly IntPtr NativeFieldInfoPtr_damageDodgeTimer;

	// Token: 0x0400483C RID: 18492
	private static readonly IntPtr NativeFieldInfoPtr_repulseTimer;

	// Token: 0x0400483D RID: 18493
	private static readonly IntPtr NativeFieldInfoPtr_shotEffect;

	// Token: 0x0400483E RID: 18494
	private static readonly IntPtr NativeFieldInfoPtr_hardBody;

	// Token: 0x0400483F RID: 18495
	private static readonly IntPtr NativeFieldInfoPtr_dodgeDamage;

	// Token: 0x04004840 RID: 18496
	private static readonly IntPtr NativeFieldInfoPtr_prayerAttackTimer;

	// Token: 0x04004841 RID: 18497
	private static readonly IntPtr NativeFieldInfoPtr_nextAttack;

	// Token: 0x04004842 RID: 18498
	private static readonly IntPtr NativeFieldInfoPtr_nextAirAttack;

	// Token: 0x04004843 RID: 18499
	private static readonly IntPtr NativeFieldInfoPtr_airAttackTimer;

	// Token: 0x04004844 RID: 18500
	private static readonly IntPtr NativeFieldInfoPtr_waitTime;

	// Token: 0x04004845 RID: 18501
	private static readonly IntPtr NativeFieldInfoPtr_noFireWaitTime;

	// Token: 0x04004846 RID: 18502
	private static readonly IntPtr NativeFieldInfoPtr_aimTime;

	// Token: 0x04004847 RID: 18503
	private static readonly IntPtr NativeFieldInfoPtr_shotTime;

	// Token: 0x04004848 RID: 18504
	private static readonly IntPtr NativeFieldInfoPtr_nextTime;

	// Token: 0x04004849 RID: 18505
	private static readonly IntPtr NativeFieldInfoPtr_nextEndTime;

	// Token: 0x0400484A RID: 18506
	private static readonly IntPtr NativeFieldInfoPtr_ABSORB_TIME_MAX;

	// Token: 0x0400484B RID: 18507
	private static readonly IntPtr NativeFieldInfoPtr_ABSORB_STATUS_TIME_MAX;

	// Token: 0x0400484C RID: 18508
	private static readonly IntPtr NativeFieldInfoPtr_ABSORB_CD_TIME_MAX;

	// Token: 0x0400484D RID: 18509
	private static readonly IntPtr NativeFieldInfoPtr_FULL_TIMER_LIMIT;

	// Token: 0x0400484E RID: 18510
	private static readonly IntPtr NativeFieldInfoPtr_REPULSE_TIME_MAX;

	// Token: 0x0400484F RID: 18511
	private static readonly IntPtr NativeFieldInfoPtr_PRAYER_ATTACK_TIME_MAX;

	// Token: 0x04004850 RID: 18512
	private static readonly IntPtr NativeMethodInfoPtr_get_Controllable_Public_get_Boolean_0;

	// Token: 0x04004851 RID: 18513
	private static readonly IntPtr NativeMethodInfoPtr_get_IsDead_Public_get_Boolean_0;

	// Token: 0x04004852 RID: 18514
	private static readonly IntPtr NativeMethodInfoPtr_get_DeltaTime_Public_get_Single_0;

	// Token: 0x04004853 RID: 18515
	private static readonly IntPtr NativeMethodInfoPtr_get_TimeScale_Public_get_Single_0;

	// Token: 0x04004854 RID: 18516
	private static readonly IntPtr NativeMethodInfoPtr_get_MoveSpeed_Public_get_Single_0;

	// Token: 0x04004855 RID: 18517
	private static readonly IntPtr NativeMethodInfoPtr_get_JumpMoveSpeed_Public_get_Single_0;

	// Token: 0x04004856 RID: 18518
	private static readonly IntPtr NativeMethodInfoPtr_get_RotationSpeed_Public_get_Single_0;

	// Token: 0x04004857 RID: 18519
	private static readonly IntPtr NativeMethodInfoPtr_get_MoveSpeedScale_Public_get_Single_0;

	// Token: 0x04004858 RID: 18520
	private static readonly IntPtr NativeMethodInfoPtr_get_MoveDirection_Public_get_Vector3_0;

	// Token: 0x04004859 RID: 18521
	private static readonly IntPtr NativeMethodInfoPtr_get_JumpDirection_Public_get_Vector3_0;

	// Token: 0x0400485A RID: 18522
	private static readonly IntPtr NativeMethodInfoPtr_get_JumpForce_Public_get_Single_0;

	// Token: 0x0400485B RID: 18523
	private static readonly IntPtr NativeMethodInfoPtr_get_Gravity_Public_get_Single_0;

	// Token: 0x0400485C RID: 18524
	private static readonly IntPtr NativeMethodInfoPtr_get_IsPond_Public_get_Boolean_0;

	// Token: 0x0400485D RID: 18525
	private static readonly IntPtr NativeMethodInfoPtr_get_PondHeight_Public_get_Single_0;

	// Token: 0x0400485E RID: 18526
	private static readonly IntPtr NativeMethodInfoPtr_get_IsSky_Public_get_Boolean_0;

	// Token: 0x0400485F RID: 18527
	private static readonly IntPtr NativeMethodInfoPtr_get_FallSpeedMax_Public_get_Single_0;

	// Token: 0x04004860 RID: 18528
	private static readonly IntPtr NativeMethodInfoPtr_get_FallTimer_Public_get_Single_0;

	// Token: 0x04004861 RID: 18529
	private static readonly IntPtr NativeMethodInfoPtr_get_AimReadyWight_Public_get_Single_0;

	// Token: 0x04004862 RID: 18530
	private static readonly IntPtr NativeMethodInfoPtr_get_AimWight_Public_get_Single_0;

	// Token: 0x04004863 RID: 18531
	private static readonly IntPtr NativeMethodInfoPtr_get_HoldingShot_Public_get_Single_0;

	// Token: 0x04004864 RID: 18532
	private static readonly IntPtr NativeMethodInfoPtr_set_HoldingShot_Public_set_Void_Single_0;

	// Token: 0x04004865 RID: 18533
	private static readonly IntPtr NativeMethodInfoPtr_get_HPRecovery_Public_get_Single_0;

	// Token: 0x04004866 RID: 18534
	private static readonly IntPtr NativeMethodInfoPtr_get_MPRecovery_Public_get_Single_0;

	// Token: 0x04004867 RID: 18535
	private static readonly IntPtr NativeMethodInfoPtr_get_MPRecoveryExternal_Public_get_Single_0;

	// Token: 0x04004868 RID: 18536
	private static readonly IntPtr NativeMethodInfoPtr_get_MagicLockTargets_Public_get_Il2CppReferenceArray_1_Transform_0;

	// Token: 0x04004869 RID: 18537
	private static readonly IntPtr NativeMethodInfoPtr_get_HasMagicLockTargets_Public_get_Boolean_0;

	// Token: 0x0400486A RID: 18538
	private static readonly IntPtr NativeMethodInfoPtr_get_StaminaLossDodge_Public_get_Single_0;

	// Token: 0x0400486B RID: 18539
	private static readonly IntPtr NativeMethodInfoPtr_get_StaminaLossDash_Public_get_Single_0;

	// Token: 0x0400486C RID: 18540
	private static readonly IntPtr NativeMethodInfoPtr_get_StaminaLossFall_Public_get_Single_0;

	// Token: 0x0400486D RID: 18541
	private static readonly IntPtr NativeMethodInfoPtr_get_StaminaLossJump_Public_get_Single_0;

	// Token: 0x0400486E RID: 18542
	private static readonly IntPtr NativeMethodInfoPtr_get_AbsorbTimer_Public_get_Single_0;

	// Token: 0x0400486F RID: 18543
	private static readonly IntPtr NativeMethodInfoPtr_get_AbsorbCDTimer_Public_get_Single_0;

	// Token: 0x04004870 RID: 18544
	private static readonly IntPtr NativeMethodInfoPtr_get_AbsorbStatusTimer_Public_get_Single_0;

	// Token: 0x04004871 RID: 18545
	private static readonly IntPtr NativeMethodInfoPtr_get_IsSlip_Public_get_Boolean_0;

	// Token: 0x04004872 RID: 18546
	private static readonly IntPtr NativeMethodInfoPtr_get_IsChargeEnable_Public_get_Boolean_0;

	// Token: 0x04004873 RID: 18547
	private static readonly IntPtr NativeMethodInfoPtr_get_DodgeTimer_Public_get_Single_0;

	// Token: 0x04004874 RID: 18548
	private static readonly IntPtr NativeMethodInfoPtr_get_DamageDodgeTimer_Public_get_Single_0;

	// Token: 0x04004875 RID: 18549
	private static readonly IntPtr NativeMethodInfoPtr_get_ShotEffect_Public_get_Boolean_0;

	// Token: 0x04004876 RID: 18550
	private static readonly IntPtr NativeMethodInfoPtr_get_HardBody_Public_get_Boolean_0;

	// Token: 0x04004877 RID: 18551
	private static readonly IntPtr NativeMethodInfoPtr_get_DodgeDamage_Public_get_Boolean_0;

	// Token: 0x04004878 RID: 18552
	private static readonly IntPtr NativeMethodInfoPtr_get_PrayerAttackTimer_Public_get_Single_0;

	// Token: 0x04004879 RID: 18553
	private static readonly IntPtr NativeMethodInfoPtr_get_NextAttack_Public_get_Boolean_0;

	// Token: 0x0400487A RID: 18554
	private static readonly IntPtr NativeMethodInfoPtr_get_NextAirAttack_Public_get_Boolean_0;

	// Token: 0x0400487B RID: 18555
	private static readonly IntPtr NativeMethodInfoPtr_get_AirAttackTimer_Public_get_Single_0;

	// Token: 0x0400487C RID: 18556
	private static readonly IntPtr NativeMethodInfoPtr_get_WaitTime_Public_get_Single_0;

	// Token: 0x0400487D RID: 18557
	private static readonly IntPtr NativeMethodInfoPtr_get_NoFireWaitTime_Public_get_Single_0;

	// Token: 0x0400487E RID: 18558
	private static readonly IntPtr NativeMethodInfoPtr_get_AimTime_Public_get_Single_0;

	// Token: 0x0400487F RID: 18559
	private static readonly IntPtr NativeMethodInfoPtr_get_ShotTime_Public_get_Single_0;

	// Token: 0x04004880 RID: 18560
	private static readonly IntPtr NativeMethodInfoPtr_get_NextTime_Public_get_Single_0;

	// Token: 0x04004881 RID: 18561
	private static readonly IntPtr NativeMethodInfoPtr_get_NextEndTime_Public_get_Single_0;

	// Token: 0x04004882 RID: 18562
	private static readonly IntPtr NativeMethodInfoPtr_UpdateControllable_Public_Void_Boolean_0;

	// Token: 0x04004883 RID: 18563
	private static readonly IntPtr NativeMethodInfoPtr_UpdateIsDead_Public_Void_Boolean_0;

	// Token: 0x04004884 RID: 18564
	private static readonly IntPtr NativeMethodInfoPtr_UpdateTimeMembers_Public_Void_Single_0;

	// Token: 0x04004885 RID: 18565
	private static readonly IntPtr NativeMethodInfoPtr_UpdateMoveSpeed_Public_Void_Single_0;

	// Token: 0x04004886 RID: 18566
	private static readonly IntPtr NativeMethodInfoPtr_UpdateMoveDirection_Public_Void_Vector3_0;

	// Token: 0x04004887 RID: 18567
	private static readonly IntPtr NativeMethodInfoPtr_UpdateJumpDirection_Public_Void_0;

	// Token: 0x04004888 RID: 18568
	private static readonly IntPtr NativeMethodInfoPtr_UpdateJumpDirection_Public_Void_Transform_0;

	// Token: 0x04004889 RID: 18569
	private static readonly IntPtr NativeMethodInfoPtr_IncreaseDamagedAirStayTimer_Public_Void_0;

	// Token: 0x0400488A RID: 18570
	private static readonly IntPtr NativeMethodInfoPtr_ResetDamagedAirStayTimer_Public_Void_0;

	// Token: 0x0400488B RID: 18571
	private static readonly IntPtr NativeMethodInfoPtr_UpdateJumpMoveSpeed_Public_Void_Single_0;

	// Token: 0x0400488C RID: 18572
	private static readonly IntPtr NativeMethodInfoPtr_UpdateIsPond_Public_Void_Boolean_0;

	// Token: 0x0400488D RID: 18573
	private static readonly IntPtr NativeMethodInfoPtr_UpdatePondHeight_Public_Void_Single_0;

	// Token: 0x0400488E RID: 18574
	private static readonly IntPtr NativeMethodInfoPtr_UpdateIsSky_Public_Void_Boolean_0;

	// Token: 0x0400488F RID: 18575
	private static readonly IntPtr NativeMethodInfoPtr_UpdateFallTimer_Public_Void_Transform_0;

	// Token: 0x04004890 RID: 18576
	private static readonly IntPtr NativeMethodInfoPtr_UpdateAimReadyWight_Public_Void_Single_0;

	// Token: 0x04004891 RID: 18577
	private static readonly IntPtr NativeMethodInfoPtr_UpdateAimWight_Public_Void_Single_0;

	// Token: 0x04004892 RID: 18578
	private static readonly IntPtr NativeMethodInfoPtr_ResetAimWightValues_Public_Void_0;

	// Token: 0x04004893 RID: 18579
	private static readonly IntPtr NativeMethodInfoPtr_UpdateHPRecovery_Public_Void_Single_0;

	// Token: 0x04004894 RID: 18580
	private static readonly IntPtr NativeMethodInfoPtr_UpdateMPRecovery_Public_Void_Single_0;

	// Token: 0x04004895 RID: 18581
	private static readonly IntPtr NativeMethodInfoPtr_UpdateMPRecoveryExternal_Public_Void_Single_0;

	// Token: 0x04004896 RID: 18582
	private static readonly IntPtr NativeMethodInfoPtr_UpdateLockTargets_Public_Void_0;

	// Token: 0x04004897 RID: 18583
	private static readonly IntPtr NativeMethodInfoPtr_GetLockTarget_Public_Transform_0;

	// Token: 0x04004898 RID: 18584
	private static readonly IntPtr NativeMethodInfoPtr_DecreaseAbsorbTimers_Public_Void_0;

	// Token: 0x04004899 RID: 18585
	private static readonly IntPtr NativeMethodInfoPtr_ResetAbsorbTimers_Public_Void_0;

	// Token: 0x0400489A RID: 18586
	private static readonly IntPtr NativeMethodInfoPtr_ResetAbsorbStatusTimer_Public_Void_0;

	// Token: 0x0400489B RID: 18587
	private static readonly IntPtr NativeMethodInfoPtr_FillAbsorbTimer_Public_Void_0;

	// Token: 0x0400489C RID: 18588
	private static readonly IntPtr NativeMethodInfoPtr_FillAbsorbCDTimer_Public_Void_0;

	// Token: 0x0400489D RID: 18589
	private static readonly IntPtr NativeMethodInfoPtr_FillAbsorbStatusTimer_Public_Void_0;

	// Token: 0x0400489E RID: 18590
	private static readonly IntPtr NativeMethodInfoPtr_UpdateSlipFlag_Public_Void_Boolean_0;

	// Token: 0x0400489F RID: 18591
	private static readonly IntPtr NativeMethodInfoPtr_UpdateChargeEnabled_Public_Void_Boolean_0;

	// Token: 0x040048A0 RID: 18592
	private static readonly IntPtr NativeMethodInfoPtr_ReverseChargeEnabled_Public_Void_0;

	// Token: 0x040048A1 RID: 18593
	private static readonly IntPtr NativeMethodInfoPtr_DecreaseDodgeTimer_Public_Void_0;

	// Token: 0x040048A2 RID: 18594
	private static readonly IntPtr NativeMethodInfoPtr_UpdateDodgeTimer_Public_Void_Single_0;

	// Token: 0x040048A3 RID: 18595
	private static readonly IntPtr NativeMethodInfoPtr_DecreaseDamageDodgeTimer_Public_Void_0;

	// Token: 0x040048A4 RID: 18596
	private static readonly IntPtr NativeMethodInfoPtr_UpdateDamageDodgeTimer_Public_Void_Single_0;

	// Token: 0x040048A5 RID: 18597
	private static readonly IntPtr NativeMethodInfoPtr_UpdateShotEffect_Public_Void_Boolean_0;

	// Token: 0x040048A6 RID: 18598
	private static readonly IntPtr NativeMethodInfoPtr_UpdateHardBody_Public_Void_Boolean_0;

	// Token: 0x040048A7 RID: 18599
	private static readonly IntPtr NativeMethodInfoPtr_UpdateDodgeDamage_Public_Void_Boolean_0;

	// Token: 0x040048A8 RID: 18600
	private static readonly IntPtr NativeMethodInfoPtr_FillPrayerAttackTimer_Public_Void_0;

	// Token: 0x040048A9 RID: 18601
	private static readonly IntPtr NativeMethodInfoPtr_DecreasePrayerAttackTimer_Public_Void_0;

	// Token: 0x040048AA RID: 18602
	private static readonly IntPtr NativeMethodInfoPtr_UpdateNextAttack_Public_Void_Boolean_0;

	// Token: 0x040048AB RID: 18603
	private static readonly IntPtr NativeMethodInfoPtr_UpdateNextAirAttack_Public_Void_Boolean_0;

	// Token: 0x040048AC RID: 18604
	private static readonly IntPtr NativeMethodInfoPtr_UpdateAirAttackTimer_Public_Void_Single_0;

	// Token: 0x040048AD RID: 18605
	private static readonly IntPtr NativeMethodInfoPtr_IncreaseAirAttackTimer_Public_Void_Single_0;

	// Token: 0x040048AE RID: 18606
	private static readonly IntPtr NativeMethodInfoPtr_DecreaseAirAttackTimer_Public_Void_0;

	// Token: 0x040048AF RID: 18607
	private static readonly IntPtr NativeMethodInfoPtr_UpdateWaitTime_Public_Void_Single_0;

	// Token: 0x040048B0 RID: 18608
	private static readonly IntPtr NativeMethodInfoPtr_DecreaseWaitTime_Public_Void_0;

	// Token: 0x040048B1 RID: 18609
	private static readonly IntPtr NativeMethodInfoPtr_UpdateNoFireWaitTime_Public_Void_Single_0;

	// Token: 0x040048B2 RID: 18610
	private static readonly IntPtr NativeMethodInfoPtr_DecreaseNoFireWaitTime_Public_Void_0;

	// Token: 0x040048B3 RID: 18611
	private static readonly IntPtr NativeMethodInfoPtr_ResetNoFireWaitTime_Public_Void_0;

	// Token: 0x040048B4 RID: 18612
	private static readonly IntPtr NativeMethodInfoPtr_UpdateAimTime_Public_Void_Single_0;

	// Token: 0x040048B5 RID: 18613
	private static readonly IntPtr NativeMethodInfoPtr_UpdateShotTime_Public_Void_Single_0;

	// Token: 0x040048B6 RID: 18614
	private static readonly IntPtr NativeMethodInfoPtr_UpdateNextTime_Public_Void_Single_0;

	// Token: 0x040048B7 RID: 18615
	private static readonly IntPtr NativeMethodInfoPtr_UpdateNextEndTime_Public_Void_Single_0;

	// Token: 0x040048B8 RID: 18616
	private static readonly IntPtr NativeMethodInfoPtr_ResetAllCharacterValue_Public_Void_0;

	// Token: 0x040048B9 RID: 18617
	private static readonly IntPtr NativeMethodInfoPtr_CalculateRepulseTimer_Public_Boolean_Single_0;

	// Token: 0x040048BA RID: 18618
	private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
}