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

// Token: 0x0200003E RID: 62
public class LogHistory : Il2CppSystem.Object
{
	// Token: 0x17000240 RID: 576
	// (get) Token: 0x0600064D RID: 1613 RVA: 0x0001AA80 File Offset: 0x00018C80
	// (set) Token: 0x0600064E RID: 1614 RVA: 0x0001AAD0 File Offset: 0x00018CD0
	public unsafe int ErrorCount
	{
		[CallerCount(4)]
		[CachedScanResults(RefRangeStart = 22660, RefRangeEnd = 22664, XrefRangeStart = 22660, XrefRangeEnd = 22664, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LogHistory.NativeMethodInfoPtr_get_ErrorCount_Public_get_Int32_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(LogHistory.NativeMethodInfoPtr_set_ErrorCount_Private_set_Void_Int32_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}
		}
	}

	// Token: 0x17000241 RID: 577
	// (get) Token: 0x0600064F RID: 1615 RVA: 0x0001AB24 File Offset: 0x00018D24
	// (set) Token: 0x06000650 RID: 1616 RVA: 0x0001AB74 File Offset: 0x00018D74
	public unsafe int AssertCount
	{
		[CallerCount(0)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LogHistory.NativeMethodInfoPtr_get_AssertCount_Public_get_Int32_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(LogHistory.NativeMethodInfoPtr_set_AssertCount_Private_set_Void_Int32_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}
		}
	}

	// Token: 0x17000242 RID: 578
	// (get) Token: 0x06000651 RID: 1617 RVA: 0x0001ABC8 File Offset: 0x00018DC8
	// (set) Token: 0x06000652 RID: 1618 RVA: 0x0001AC18 File Offset: 0x00018E18
	public unsafe int WarningCount
	{
		[CallerCount(5)]
		[CachedScanResults(RefRangeStart = 21079, RefRangeEnd = 21084, XrefRangeStart = 21079, XrefRangeEnd = 21084, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LogHistory.NativeMethodInfoPtr_get_WarningCount_Public_get_Int32_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(LogHistory.NativeMethodInfoPtr_set_WarningCount_Private_set_Void_Int32_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}
		}
	}

	// Token: 0x17000243 RID: 579
	// (get) Token: 0x06000653 RID: 1619 RVA: 0x0001AC6C File Offset: 0x00018E6C
	// (set) Token: 0x06000654 RID: 1620 RVA: 0x0001ACBC File Offset: 0x00018EBC
	public unsafe int RegularLogCount
	{
		[CallerCount(8)]
		[CachedScanResults(RefRangeStart = 21085, RefRangeEnd = 21093, XrefRangeStart = 21085, XrefRangeEnd = 21093, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LogHistory.NativeMethodInfoPtr_get_RegularLogCount_Public_get_Int32_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(LogHistory.NativeMethodInfoPtr_set_RegularLogCount_Private_set_Void_Int32_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}
		}
	}

	// Token: 0x17000244 RID: 580
	// (get) Token: 0x06000655 RID: 1621 RVA: 0x0001AD10 File Offset: 0x00018F10
	// (set) Token: 0x06000656 RID: 1622 RVA: 0x0001AD60 File Offset: 0x00018F60
	public unsafe int ExceptionCount
	{
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 21093, RefRangeEnd = 21094, XrefRangeStart = 21093, XrefRangeEnd = 21094, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LogHistory.NativeMethodInfoPtr_get_ExceptionCount_Public_get_Int32_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}
		[CallerCount(3)]
		[CachedScanResults(RefRangeStart = 61504, RefRangeEnd = 61507, XrefRangeStart = 61504, XrefRangeEnd = 61507, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		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(LogHistory.NativeMethodInfoPtr_set_ExceptionCount_Private_set_Void_Int32_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}
		}
	}

	// Token: 0x17000245 RID: 581
	// (get) Token: 0x06000657 RID: 1623 RVA: 0x0001ADB4 File Offset: 0x00018FB4
	public unsafe IList<LogHistoryItem> LogItems
	{
		[CallerCount(4)]
		[CachedScanResults(RefRangeStart = 471422, RefRangeEnd = 471426, XrefRangeStart = 471418, XrefRangeEnd = 471422, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		get
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LogHistory.NativeMethodInfoPtr_get_LogItems_Public_get_IList_1_LogHistoryItem_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			IntPtr intPtr3 = intPtr;
			return (intPtr3 != 0) ? new IList<LogHistoryItem>(intPtr3) : null;
		}
	}

	// Token: 0x17000246 RID: 582
	// (get) Token: 0x06000658 RID: 1624 RVA: 0x0001AE0C File Offset: 0x0001900C
	public unsafe static LogHistory Instance
	{
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 471426, XrefRangeEnd = 471430, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		get
		{
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LogHistory.NativeMethodInfoPtr_get_Instance_Public_Static_get_LogHistory_0, 0, (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			IntPtr intPtr3 = intPtr;
			return (intPtr3 != 0) ? new LogHistory(intPtr3) : null;
		}
	}

	// Token: 0x06000659 RID: 1625 RVA: 0x0001AE54 File Offset: 0x00019054
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 471435, RefRangeEnd = 471437, XrefRangeStart = 471430, XrefRangeEnd = 471435, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void add_LogHistoryItemAdded(Action<LogHistoryItem> value)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = IL2CPP.Il2CppObjectBaseToPtr(value);
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LogHistory.NativeMethodInfoPtr_add_LogHistoryItemAdded_Public_add_Void_Action_1_LogHistoryItem_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x0600065A RID: 1626 RVA: 0x0001AEB0 File Offset: 0x000190B0
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 471437, XrefRangeEnd = 471442, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void remove_LogHistoryItemAdded(Action<LogHistoryItem> value)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = IL2CPP.Il2CppObjectBaseToPtr(value);
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LogHistory.NativeMethodInfoPtr_remove_LogHistoryItemAdded_Public_rem_Void_Action_1_LogHistoryItem_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x0600065B RID: 1627 RVA: 0x0001AF0C File Offset: 0x0001910C
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 471442, XrefRangeEnd = 471447, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void add_LogHistoryItemRemoved(Action<LogHistoryItem> value)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = IL2CPP.Il2CppObjectBaseToPtr(value);
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LogHistory.NativeMethodInfoPtr_add_LogHistoryItemRemoved_Public_add_Void_Action_1_LogHistoryItem_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x0600065C RID: 1628 RVA: 0x0001AF68 File Offset: 0x00019168
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 471447, XrefRangeEnd = 471452, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void remove_LogHistoryItemRemoved(Action<LogHistoryItem> value)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = IL2CPP.Il2CppObjectBaseToPtr(value);
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LogHistory.NativeMethodInfoPtr_remove_LogHistoryItemRemoved_Public_rem_Void_Action_1_LogHistoryItem_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x0600065D RID: 1629 RVA: 0x0001AFC4 File Offset: 0x000191C4
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 471452, XrefRangeEnd = 471457, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void add_LogHistoryCleared(Action value)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = IL2CPP.Il2CppObjectBaseToPtr(value);
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LogHistory.NativeMethodInfoPtr_add_LogHistoryCleared_Public_add_Void_Action_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x0600065E RID: 1630 RVA: 0x0001B020 File Offset: 0x00019220
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 471457, XrefRangeEnd = 471462, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void remove_LogHistoryCleared(Action value)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = IL2CPP.Il2CppObjectBaseToPtr(value);
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LogHistory.NativeMethodInfoPtr_remove_LogHistoryCleared_Public_rem_Void_Action_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}
	}

	// Token: 0x0600065F RID: 1631 RVA: 0x0001B07C File Offset: 0x0001927C
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 471559, RefRangeEnd = 471561, XrefRangeStart = 471462, XrefRangeEnd = 471559, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe LogHistory()
		: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<LogHistory>.NativeClassPtr))
	{
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LogHistory.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06000660 RID: 1632 RVA: 0x0001B0C8 File Offset: 0x000192C8
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 471575, RefRangeEnd = 471576, XrefRangeStart = 471561, XrefRangeEnd = 471575, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe virtual void Dispose()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LogHistory.NativeMethodInfoPtr_Dispose_Public_Virtual_Final_New_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06000661 RID: 1633 RVA: 0x0001B10C File Offset: 0x0001930C
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 471585, RefRangeEnd = 471586, XrefRangeStart = 471576, XrefRangeEnd = 471585, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void Clear()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LogHistory.NativeMethodInfoPtr_Clear_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06000662 RID: 1634 RVA: 0x0001B150 File Offset: 0x00019350
	[CallerCount(2)]
	[CachedScanResults(RefRangeStart = 471631, RefRangeEnd = 471633, XrefRangeStart = 471586, XrefRangeEnd = 471631, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void Update()
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr = null;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LogHistory.NativeMethodInfoPtr_Update_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06000663 RID: 1635 RVA: 0x0001B194 File Offset: 0x00019394
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 471664, RefRangeEnd = 471665, XrefRangeStart = 471633, XrefRangeEnd = 471664, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe string GetFilterStackTrace(string stackTrace)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		checked
		{
			IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
			*ptr = IL2CPP.ManagedStringToIl2Cpp(stackTrace);
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LogHistory.NativeMethodInfoPtr_GetFilterStackTrace_Private_String_String_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return IL2CPP.Il2CppStringToManaged(intPtr);
		}
	}

	// Token: 0x06000664 RID: 1636 RVA: 0x0001B1F8 File Offset: 0x000193F8
	[CallerCount(1)]
	[CachedScanResults(RefRangeStart = 471668, RefRangeEnd = 471669, XrefRangeStart = 471665, XrefRangeEnd = 471668, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe Il2CppArrayBase<T> GetSubArray<T>(Il2CppArrayBase<T> data, int index, int length)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
			*ptr = IL2CPP.Il2CppObjectBaseToPtr(data);
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref index;
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref length;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LogHistory.MethodInfoStoreGeneric_GetSubArray_Private_Il2CppArrayBase_1_T_Il2CppArrayBase_1_T_Int32_Int32_0<T>.Pointer, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		return Il2CppArrayBase<T>.WrapNativeGenericArrayPointer(intPtr);
	}

	// Token: 0x06000665 RID: 1637 RVA: 0x0001B280 File Offset: 0x00019480
	[CallerCount(0)]
	public unsafe void UpdateTypeCounter(LogType type, int count)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = ref type;
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref count;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LogHistory.NativeMethodInfoPtr_UpdateTypeCounter_Private_Void_LogType_Int32_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06000666 RID: 1638 RVA: 0x0001B2E8 File Offset: 0x000194E8
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 471669, XrefRangeEnd = 471687, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void HandleLoggingEvent(string logString, string stackTrace, LogType type)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
			*ptr = IL2CPP.ManagedStringToIl2Cpp(logString);
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.ManagedStringToIl2Cpp(stackTrace);
		ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref type;
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LogHistory.NativeMethodInfoPtr_HandleLoggingEvent_Private_Void_String_String_LogType_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06000667 RID: 1639 RVA: 0x0001B36C File Offset: 0x0001956C
	[CallerCount(0)]
	[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 471687, XrefRangeEnd = 471696, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
	public unsafe void HandleUnhandledException(Il2CppSystem.Object sender, UnhandledExceptionEventArgs e)
	{
		IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
		IntPtr* ptr;
		checked
		{
			ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
			*ptr = IL2CPP.Il2CppObjectBaseToPtr(sender);
		}
		ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(e);
		IntPtr intPtr2;
		IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LogHistory.NativeMethodInfoPtr_HandleUnhandledException_Private_Void_Object_UnhandledExceptionEventArgs_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
		Il2CppException.RaiseExceptionIfNecessary(intPtr2);
	}

	// Token: 0x06000668 RID: 1640 RVA: 0x0001B3E0 File Offset: 0x000195E0
	// Note: this type is marked as 'beforefieldinit'.
	static LogHistory()
	{
		Il2CppClassPointerStore<LogHistory>.NativeClassPtr = IL2CPP.GetIl2CppClass("Assembly-CSharp.dll", "", "LogHistory");
		IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<LogHistory>.NativeClassPtr);
		LogHistory.NativeFieldInfoPtr_ITEM_LIMIT = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LogHistory>.NativeClassPtr, "ITEM_LIMIT");
		LogHistory.NativeFieldInfoPtr_instance = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LogHistory>.NativeClassPtr, "instance");
		LogHistory.NativeFieldInfoPtr_gameStartTime = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LogHistory>.NativeClassPtr, "gameStartTime");
		LogHistory.NativeFieldInfoPtr_lockLogItemObject = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LogHistory>.NativeClassPtr, "lockLogItemObject");
		LogHistory.NativeFieldInfoPtr_deferredLogItems = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LogHistory>.NativeClassPtr, "deferredLogItems");
		LogHistory.NativeFieldInfoPtr_logItems = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LogHistory>.NativeClassPtr, "logItems");
		LogHistory.NativeFieldInfoPtr_logHistoryItemAdded = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LogHistory>.NativeClassPtr, "logHistoryItemAdded");
		LogHistory.NativeFieldInfoPtr_logHistoryItemRemoved = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LogHistory>.NativeClassPtr, "logHistoryItemRemoved");
		LogHistory.NativeFieldInfoPtr_logHistoryCleared = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LogHistory>.NativeClassPtr, "logHistoryCleared");
		LogHistory.NativeFieldInfoPtr__ErrorCount_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LogHistory>.NativeClassPtr, "<ErrorCount>k__BackingField");
		LogHistory.NativeFieldInfoPtr__AssertCount_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LogHistory>.NativeClassPtr, "<AssertCount>k__BackingField");
		LogHistory.NativeFieldInfoPtr__WarningCount_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LogHistory>.NativeClassPtr, "<WarningCount>k__BackingField");
		LogHistory.NativeFieldInfoPtr__RegularLogCount_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LogHistory>.NativeClassPtr, "<RegularLogCount>k__BackingField");
		LogHistory.NativeFieldInfoPtr__ExceptionCount_k__BackingField = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LogHistory>.NativeClassPtr, "<ExceptionCount>k__BackingField");
		LogHistory.NativeMethodInfoPtr_get_ErrorCount_Public_get_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LogHistory>.NativeClassPtr, 100663741);
		LogHistory.NativeMethodInfoPtr_set_ErrorCount_Private_set_Void_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LogHistory>.NativeClassPtr, 100663742);
		LogHistory.NativeMethodInfoPtr_get_AssertCount_Public_get_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LogHistory>.NativeClassPtr, 100663743);
		LogHistory.NativeMethodInfoPtr_set_AssertCount_Private_set_Void_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LogHistory>.NativeClassPtr, 100663744);
		LogHistory.NativeMethodInfoPtr_get_WarningCount_Public_get_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LogHistory>.NativeClassPtr, 100663745);
		LogHistory.NativeMethodInfoPtr_set_WarningCount_Private_set_Void_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LogHistory>.NativeClassPtr, 100663746);
		LogHistory.NativeMethodInfoPtr_get_RegularLogCount_Public_get_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LogHistory>.NativeClassPtr, 100663747);
		LogHistory.NativeMethodInfoPtr_set_RegularLogCount_Private_set_Void_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LogHistory>.NativeClassPtr, 100663748);
		LogHistory.NativeMethodInfoPtr_get_ExceptionCount_Public_get_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LogHistory>.NativeClassPtr, 100663749);
		LogHistory.NativeMethodInfoPtr_set_ExceptionCount_Private_set_Void_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LogHistory>.NativeClassPtr, 100663750);
		LogHistory.NativeMethodInfoPtr_get_LogItems_Public_get_IList_1_LogHistoryItem_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LogHistory>.NativeClassPtr, 100663751);
		LogHistory.NativeMethodInfoPtr_get_Instance_Public_Static_get_LogHistory_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LogHistory>.NativeClassPtr, 100663752);
		LogHistory.NativeMethodInfoPtr_add_LogHistoryItemAdded_Public_add_Void_Action_1_LogHistoryItem_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LogHistory>.NativeClassPtr, 100663753);
		LogHistory.NativeMethodInfoPtr_remove_LogHistoryItemAdded_Public_rem_Void_Action_1_LogHistoryItem_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LogHistory>.NativeClassPtr, 100663754);
		LogHistory.NativeMethodInfoPtr_add_LogHistoryItemRemoved_Public_add_Void_Action_1_LogHistoryItem_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LogHistory>.NativeClassPtr, 100663755);
		LogHistory.NativeMethodInfoPtr_remove_LogHistoryItemRemoved_Public_rem_Void_Action_1_LogHistoryItem_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LogHistory>.NativeClassPtr, 100663756);
		LogHistory.NativeMethodInfoPtr_add_LogHistoryCleared_Public_add_Void_Action_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LogHistory>.NativeClassPtr, 100663757);
		LogHistory.NativeMethodInfoPtr_remove_LogHistoryCleared_Public_rem_Void_Action_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LogHistory>.NativeClassPtr, 100663758);
		LogHistory.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LogHistory>.NativeClassPtr, 100663759);
		LogHistory.NativeMethodInfoPtr_Dispose_Public_Virtual_Final_New_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LogHistory>.NativeClassPtr, 100663760);
		LogHistory.NativeMethodInfoPtr_Clear_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LogHistory>.NativeClassPtr, 100663761);
		LogHistory.NativeMethodInfoPtr_Update_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LogHistory>.NativeClassPtr, 100663762);
		LogHistory.NativeMethodInfoPtr_GetFilterStackTrace_Private_String_String_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LogHistory>.NativeClassPtr, 100663763);
		LogHistory.NativeMethodInfoPtr_GetSubArray_Private_Il2CppArrayBase_1_T_Il2CppArrayBase_1_T_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LogHistory>.NativeClassPtr, 100663764);
		LogHistory.NativeMethodInfoPtr_UpdateTypeCounter_Private_Void_LogType_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LogHistory>.NativeClassPtr, 100663765);
		LogHistory.NativeMethodInfoPtr_HandleLoggingEvent_Private_Void_String_String_LogType_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LogHistory>.NativeClassPtr, 100663766);
		LogHistory.NativeMethodInfoPtr_HandleUnhandledException_Private_Void_Object_UnhandledExceptionEventArgs_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LogHistory>.NativeClassPtr, 100663767);
	}

	// Token: 0x06000669 RID: 1641 RVA: 0x0000A688 File Offset: 0x00008888
	public LogHistory(IntPtr pointer)
		: base(pointer)
	{
	}

	// Token: 0x17000232 RID: 562
	// (get) Token: 0x0600066A RID: 1642 RVA: 0x0001B744 File Offset: 0x00019944
	// (set) Token: 0x0600066B RID: 1643 RVA: 0x0001B762 File Offset: 0x00019962
	public unsafe static int ITEM_LIMIT
	{
		get
		{
			int num;
			IL2CPP.il2cpp_field_static_get_value(LogHistory.NativeFieldInfoPtr_ITEM_LIMIT, (void*)(&num));
			return num;
		}
		set
		{
			IL2CPP.il2cpp_field_static_set_value(LogHistory.NativeFieldInfoPtr_ITEM_LIMIT, (void*)(&value));
		}
	}

	// Token: 0x17000233 RID: 563
	// (get) Token: 0x0600066C RID: 1644 RVA: 0x0001B774 File Offset: 0x00019974
	// (set) Token: 0x0600066D RID: 1645 RVA: 0x0001B79F File Offset: 0x0001999F
	public unsafe static LogHistory instance
	{
		get
		{
			IntPtr intPtr;
			IL2CPP.il2cpp_field_static_get_value(LogHistory.NativeFieldInfoPtr_instance, (void*)(&intPtr));
			IntPtr intPtr2 = intPtr;
			return (intPtr2 != 0) ? new LogHistory(intPtr2) : null;
		}
		set
		{
			IL2CPP.il2cpp_field_static_set_value(LogHistory.NativeFieldInfoPtr_instance, IL2CPP.Il2CppObjectBaseToPtr(value));
		}
	}

	// Token: 0x17000234 RID: 564
	// (get) Token: 0x0600066E RID: 1646 RVA: 0x0001B7B4 File Offset: 0x000199B4
	// (set) Token: 0x0600066F RID: 1647 RVA: 0x0001B7DC File Offset: 0x000199DC
	public unsafe DateTime gameStartTime
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LogHistory.NativeFieldInfoPtr_gameStartTime);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LogHistory.NativeFieldInfoPtr_gameStartTime)) = value;
		}
	}

	// Token: 0x17000235 RID: 565
	// (get) Token: 0x06000670 RID: 1648 RVA: 0x0001B800 File Offset: 0x00019A00
	// (set) Token: 0x06000671 RID: 1649 RVA: 0x0001B834 File Offset: 0x00019A34
	public unsafe Il2CppSystem.Object lockLogItemObject
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LogHistory.NativeFieldInfoPtr_lockLogItemObject);
			IntPtr intPtr2 = *intPtr;
			return (intPtr2 != 0) ? new Il2CppSystem.Object(intPtr2) : null;
		}
		set
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(LogHistory.NativeFieldInfoPtr_lockLogItemObject), IL2CPP.Il2CppObjectBaseToPtr(value));
		}
	}

	// Token: 0x17000236 RID: 566
	// (get) Token: 0x06000672 RID: 1650 RVA: 0x0001B85C File Offset: 0x00019A5C
	// (set) Token: 0x06000673 RID: 1651 RVA: 0x0001B890 File Offset: 0x00019A90
	public unsafe List<LogHistoryItem> deferredLogItems
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LogHistory.NativeFieldInfoPtr_deferredLogItems);
			IntPtr intPtr2 = *intPtr;
			return (intPtr2 != 0) ? new List<LogHistoryItem>(intPtr2) : null;
		}
		set
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(LogHistory.NativeFieldInfoPtr_deferredLogItems), IL2CPP.Il2CppObjectBaseToPtr(value));
		}
	}

	// Token: 0x17000237 RID: 567
	// (get) Token: 0x06000674 RID: 1652 RVA: 0x0001B8B8 File Offset: 0x00019AB8
	// (set) Token: 0x06000675 RID: 1653 RVA: 0x0001B8EC File Offset: 0x00019AEC
	public unsafe List<LogHistoryItem> logItems
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LogHistory.NativeFieldInfoPtr_logItems);
			IntPtr intPtr2 = *intPtr;
			return (intPtr2 != 0) ? new List<LogHistoryItem>(intPtr2) : null;
		}
		set
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(LogHistory.NativeFieldInfoPtr_logItems), IL2CPP.Il2CppObjectBaseToPtr(value));
		}
	}

	// Token: 0x17000238 RID: 568
	// (get) Token: 0x06000676 RID: 1654 RVA: 0x0001B914 File Offset: 0x00019B14
	// (set) Token: 0x06000677 RID: 1655 RVA: 0x0001B948 File Offset: 0x00019B48
	public unsafe Action<LogHistoryItem> logHistoryItemAdded
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LogHistory.NativeFieldInfoPtr_logHistoryItemAdded);
			IntPtr intPtr2 = *intPtr;
			return (intPtr2 != 0) ? new Action<LogHistoryItem>(intPtr2) : null;
		}
		set
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(LogHistory.NativeFieldInfoPtr_logHistoryItemAdded), IL2CPP.Il2CppObjectBaseToPtr(value));
		}
	}

	// Token: 0x17000239 RID: 569
	// (get) Token: 0x06000678 RID: 1656 RVA: 0x0001B970 File Offset: 0x00019B70
	// (set) Token: 0x06000679 RID: 1657 RVA: 0x0001B9A4 File Offset: 0x00019BA4
	public unsafe Action<LogHistoryItem> logHistoryItemRemoved
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LogHistory.NativeFieldInfoPtr_logHistoryItemRemoved);
			IntPtr intPtr2 = *intPtr;
			return (intPtr2 != 0) ? new Action<LogHistoryItem>(intPtr2) : null;
		}
		set
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(LogHistory.NativeFieldInfoPtr_logHistoryItemRemoved), IL2CPP.Il2CppObjectBaseToPtr(value));
		}
	}

	// Token: 0x1700023A RID: 570
	// (get) Token: 0x0600067A RID: 1658 RVA: 0x0001B9CC File Offset: 0x00019BCC
	// (set) Token: 0x0600067B RID: 1659 RVA: 0x0001BA00 File Offset: 0x00019C00
	public unsafe Action logHistoryCleared
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LogHistory.NativeFieldInfoPtr_logHistoryCleared);
			IntPtr intPtr2 = *intPtr;
			return (intPtr2 != 0) ? new Action(intPtr2) : null;
		}
		set
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(LogHistory.NativeFieldInfoPtr_logHistoryCleared), IL2CPP.Il2CppObjectBaseToPtr(value));
		}
	}

	// Token: 0x1700023B RID: 571
	// (get) Token: 0x0600067C RID: 1660 RVA: 0x0001BA28 File Offset: 0x00019C28
	// (set) Token: 0x0600067D RID: 1661 RVA: 0x0001BA50 File Offset: 0x00019C50
	public unsafe int _ErrorCount_k__BackingField
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LogHistory.NativeFieldInfoPtr__ErrorCount_k__BackingField);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LogHistory.NativeFieldInfoPtr__ErrorCount_k__BackingField)) = value;
		}
	}

	// Token: 0x1700023C RID: 572
	// (get) Token: 0x0600067E RID: 1662 RVA: 0x0001BA74 File Offset: 0x00019C74
	// (set) Token: 0x0600067F RID: 1663 RVA: 0x0001BA9C File Offset: 0x00019C9C
	public unsafe int _AssertCount_k__BackingField
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LogHistory.NativeFieldInfoPtr__AssertCount_k__BackingField);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LogHistory.NativeFieldInfoPtr__AssertCount_k__BackingField)) = value;
		}
	}

	// Token: 0x1700023D RID: 573
	// (get) Token: 0x06000680 RID: 1664 RVA: 0x0001BAC0 File Offset: 0x00019CC0
	// (set) Token: 0x06000681 RID: 1665 RVA: 0x0001BAE8 File Offset: 0x00019CE8
	public unsafe int _WarningCount_k__BackingField
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LogHistory.NativeFieldInfoPtr__WarningCount_k__BackingField);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LogHistory.NativeFieldInfoPtr__WarningCount_k__BackingField)) = value;
		}
	}

	// Token: 0x1700023E RID: 574
	// (get) Token: 0x06000682 RID: 1666 RVA: 0x0001BB0C File Offset: 0x00019D0C
	// (set) Token: 0x06000683 RID: 1667 RVA: 0x0001BB34 File Offset: 0x00019D34
	public unsafe int _RegularLogCount_k__BackingField
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LogHistory.NativeFieldInfoPtr__RegularLogCount_k__BackingField);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LogHistory.NativeFieldInfoPtr__RegularLogCount_k__BackingField)) = value;
		}
	}

	// Token: 0x1700023F RID: 575
	// (get) Token: 0x06000684 RID: 1668 RVA: 0x0001BB58 File Offset: 0x00019D58
	// (set) Token: 0x06000685 RID: 1669 RVA: 0x0001BB80 File Offset: 0x00019D80
	public unsafe int _ExceptionCount_k__BackingField
	{
		get
		{
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LogHistory.NativeFieldInfoPtr__ExceptionCount_k__BackingField);
			return *intPtr;
		}
		set
		{
			*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(LogHistory.NativeFieldInfoPtr__ExceptionCount_k__BackingField)) = value;
		}
	}

	// Token: 0x040003DC RID: 988
	private static readonly IntPtr NativeFieldInfoPtr_ITEM_LIMIT;

	// Token: 0x040003DD RID: 989
	private static readonly IntPtr NativeFieldInfoPtr_instance;

	// Token: 0x040003DE RID: 990
	private static readonly IntPtr NativeFieldInfoPtr_gameStartTime;

	// Token: 0x040003DF RID: 991
	private static readonly IntPtr NativeFieldInfoPtr_lockLogItemObject;

	// Token: 0x040003E0 RID: 992
	private static readonly IntPtr NativeFieldInfoPtr_deferredLogItems;

	// Token: 0x040003E1 RID: 993
	private static readonly IntPtr NativeFieldInfoPtr_logItems;

	// Token: 0x040003E2 RID: 994
	private static readonly IntPtr NativeFieldInfoPtr_logHistoryItemAdded;

	// Token: 0x040003E3 RID: 995
	private static readonly IntPtr NativeFieldInfoPtr_logHistoryItemRemoved;

	// Token: 0x040003E4 RID: 996
	private static readonly IntPtr NativeFieldInfoPtr_logHistoryCleared;

	// Token: 0x040003E5 RID: 997
	private static readonly IntPtr NativeFieldInfoPtr__ErrorCount_k__BackingField;

	// Token: 0x040003E6 RID: 998
	private static readonly IntPtr NativeFieldInfoPtr__AssertCount_k__BackingField;

	// Token: 0x040003E7 RID: 999
	private static readonly IntPtr NativeFieldInfoPtr__WarningCount_k__BackingField;

	// Token: 0x040003E8 RID: 1000
	private static readonly IntPtr NativeFieldInfoPtr__RegularLogCount_k__BackingField;

	// Token: 0x040003E9 RID: 1001
	private static readonly IntPtr NativeFieldInfoPtr__ExceptionCount_k__BackingField;

	// Token: 0x040003EA RID: 1002
	private static readonly IntPtr NativeMethodInfoPtr_get_ErrorCount_Public_get_Int32_0;

	// Token: 0x040003EB RID: 1003
	private static readonly IntPtr NativeMethodInfoPtr_set_ErrorCount_Private_set_Void_Int32_0;

	// Token: 0x040003EC RID: 1004
	private static readonly IntPtr NativeMethodInfoPtr_get_AssertCount_Public_get_Int32_0;

	// Token: 0x040003ED RID: 1005
	private static readonly IntPtr NativeMethodInfoPtr_set_AssertCount_Private_set_Void_Int32_0;

	// Token: 0x040003EE RID: 1006
	private static readonly IntPtr NativeMethodInfoPtr_get_WarningCount_Public_get_Int32_0;

	// Token: 0x040003EF RID: 1007
	private static readonly IntPtr NativeMethodInfoPtr_set_WarningCount_Private_set_Void_Int32_0;

	// Token: 0x040003F0 RID: 1008
	private static readonly IntPtr NativeMethodInfoPtr_get_RegularLogCount_Public_get_Int32_0;

	// Token: 0x040003F1 RID: 1009
	private static readonly IntPtr NativeMethodInfoPtr_set_RegularLogCount_Private_set_Void_Int32_0;

	// Token: 0x040003F2 RID: 1010
	private static readonly IntPtr NativeMethodInfoPtr_get_ExceptionCount_Public_get_Int32_0;

	// Token: 0x040003F3 RID: 1011
	private static readonly IntPtr NativeMethodInfoPtr_set_ExceptionCount_Private_set_Void_Int32_0;

	// Token: 0x040003F4 RID: 1012
	private static readonly IntPtr NativeMethodInfoPtr_get_LogItems_Public_get_IList_1_LogHistoryItem_0;

	// Token: 0x040003F5 RID: 1013
	private static readonly IntPtr NativeMethodInfoPtr_get_Instance_Public_Static_get_LogHistory_0;

	// Token: 0x040003F6 RID: 1014
	private static readonly IntPtr NativeMethodInfoPtr_add_LogHistoryItemAdded_Public_add_Void_Action_1_LogHistoryItem_0;

	// Token: 0x040003F7 RID: 1015
	private static readonly IntPtr NativeMethodInfoPtr_remove_LogHistoryItemAdded_Public_rem_Void_Action_1_LogHistoryItem_0;

	// Token: 0x040003F8 RID: 1016
	private static readonly IntPtr NativeMethodInfoPtr_add_LogHistoryItemRemoved_Public_add_Void_Action_1_LogHistoryItem_0;

	// Token: 0x040003F9 RID: 1017
	private static readonly IntPtr NativeMethodInfoPtr_remove_LogHistoryItemRemoved_Public_rem_Void_Action_1_LogHistoryItem_0;

	// Token: 0x040003FA RID: 1018
	private static readonly IntPtr NativeMethodInfoPtr_add_LogHistoryCleared_Public_add_Void_Action_0;

	// Token: 0x040003FB RID: 1019
	private static readonly IntPtr NativeMethodInfoPtr_remove_LogHistoryCleared_Public_rem_Void_Action_0;

	// Token: 0x040003FC RID: 1020
	private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

	// Token: 0x040003FD RID: 1021
	private static readonly IntPtr NativeMethodInfoPtr_Dispose_Public_Virtual_Final_New_Void_0;

	// Token: 0x040003FE RID: 1022
	private static readonly IntPtr NativeMethodInfoPtr_Clear_Public_Void_0;

	// Token: 0x040003FF RID: 1023
	private static readonly IntPtr NativeMethodInfoPtr_Update_Public_Void_0;

	// Token: 0x04000400 RID: 1024
	private static readonly IntPtr NativeMethodInfoPtr_GetFilterStackTrace_Private_String_String_0;

	// Token: 0x04000401 RID: 1025
	private static readonly IntPtr NativeMethodInfoPtr_GetSubArray_Private_Il2CppArrayBase_1_T_Il2CppArrayBase_1_T_Int32_Int32_0;

	// Token: 0x04000402 RID: 1026
	private static readonly IntPtr NativeMethodInfoPtr_UpdateTypeCounter_Private_Void_LogType_Int32_0;

	// Token: 0x04000403 RID: 1027
	private static readonly IntPtr NativeMethodInfoPtr_HandleLoggingEvent_Private_Void_String_String_LogType_0;

	// Token: 0x04000404 RID: 1028
	private static readonly IntPtr NativeMethodInfoPtr_HandleUnhandledException_Private_Void_Object_UnhandledExceptionEventArgs_0;

	// Token: 0x0200003F RID: 63
	[ObfuscatedName("LogHistory/<>c")]
	[Serializable]
	public sealed class __c : Il2CppSystem.Object
	{
		// Token: 0x06000686 RID: 1670 RVA: 0x0001BBA4 File Offset: 0x00019DA4
		[CallerCount(1642)]
		[CachedScanResults(RefRangeStart = 7417, RefRangeEnd = 9059, XrefRangeStart = 7417, XrefRangeEnd = 9059, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe __c()
			: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<LogHistory.__c>.NativeClassPtr))
		{
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LogHistory.__c.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06000687 RID: 1671 RVA: 0x0001BBF0 File Offset: 0x00019DF0
		[CallerCount(5585)]
		[CachedScanResults(RefRangeStart = 24, RefRangeEnd = 5609, XrefRangeStart = 24, XrefRangeEnd = 5609, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void __ctor_b__42_0(LogHistoryItem <p0>)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(<p0>);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LogHistory.__c.NativeMethodInfoPtr___ctor_b__42_0_Internal_Void_LogHistoryItem_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}
		}

		// Token: 0x06000688 RID: 1672 RVA: 0x0001BC4C File Offset: 0x00019E4C
		[CallerCount(5585)]
		[CachedScanResults(RefRangeStart = 24, RefRangeEnd = 5609, XrefRangeStart = 24, XrefRangeEnd = 5609, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void __ctor_b__42_1(LogHistoryItem <p0>)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(<p0>);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LogHistory.__c.NativeMethodInfoPtr___ctor_b__42_1_Internal_Void_LogHistoryItem_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}
		}

		// Token: 0x06000689 RID: 1673 RVA: 0x0001BCA8 File Offset: 0x00019EA8
		[CallerCount(5585)]
		[CachedScanResults(RefRangeStart = 24, RefRangeEnd = 5609, XrefRangeStart = 24, XrefRangeEnd = 5609, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void __ctor_b__42_2()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(LogHistory.__c.NativeMethodInfoPtr___ctor_b__42_2_Internal_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x0600068A RID: 1674 RVA: 0x0001BCEC File Offset: 0x00019EEC
		// Note: this type is marked as 'beforefieldinit'.
		static __c()
		{
			Il2CppClassPointerStore<LogHistory.__c>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<LogHistory>.NativeClassPtr, "<>c");
			IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<LogHistory.__c>.NativeClassPtr);
			LogHistory.__c.NativeFieldInfoPtr___9 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LogHistory.__c>.NativeClassPtr, "<>9");
			LogHistory.__c.NativeFieldInfoPtr___9__42_0 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LogHistory.__c>.NativeClassPtr, "<>9__42_0");
			LogHistory.__c.NativeFieldInfoPtr___9__42_1 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LogHistory.__c>.NativeClassPtr, "<>9__42_1");
			LogHistory.__c.NativeFieldInfoPtr___9__42_2 = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<LogHistory.__c>.NativeClassPtr, "<>9__42_2");
			LogHistory.__c.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LogHistory.__c>.NativeClassPtr, 100663770);
			LogHistory.__c.NativeMethodInfoPtr___ctor_b__42_0_Internal_Void_LogHistoryItem_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LogHistory.__c>.NativeClassPtr, 100663771);
			LogHistory.__c.NativeMethodInfoPtr___ctor_b__42_1_Internal_Void_LogHistoryItem_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LogHistory.__c>.NativeClassPtr, 100663772);
			LogHistory.__c.NativeMethodInfoPtr___ctor_b__42_2_Internal_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<LogHistory.__c>.NativeClassPtr, 100663773);
		}

		// Token: 0x0600068B RID: 1675 RVA: 0x0000A688 File Offset: 0x00008888
		public __c(IntPtr pointer)
			: base(pointer)
		{
		}

		// Token: 0x17000247 RID: 583
		// (get) Token: 0x0600068C RID: 1676 RVA: 0x0001BDB8 File Offset: 0x00019FB8
		// (set) Token: 0x0600068D RID: 1677 RVA: 0x0001BDE3 File Offset: 0x00019FE3
		public unsafe static LogHistory.__c __9
		{
			get
			{
				IntPtr intPtr;
				IL2CPP.il2cpp_field_static_get_value(LogHistory.__c.NativeFieldInfoPtr___9, (void*)(&intPtr));
				IntPtr intPtr2 = intPtr;
				return (intPtr2 != 0) ? new LogHistory.__c(intPtr2) : null;
			}
			set
			{
				IL2CPP.il2cpp_field_static_set_value(LogHistory.__c.NativeFieldInfoPtr___9, IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17000248 RID: 584
		// (get) Token: 0x0600068E RID: 1678 RVA: 0x0001BDF8 File Offset: 0x00019FF8
		// (set) Token: 0x0600068F RID: 1679 RVA: 0x0001BE23 File Offset: 0x0001A023
		public unsafe static Action<LogHistoryItem> __9__42_0
		{
			get
			{
				IntPtr intPtr;
				IL2CPP.il2cpp_field_static_get_value(LogHistory.__c.NativeFieldInfoPtr___9__42_0, (void*)(&intPtr));
				IntPtr intPtr2 = intPtr;
				return (intPtr2 != 0) ? new Action<LogHistoryItem>(intPtr2) : null;
			}
			set
			{
				IL2CPP.il2cpp_field_static_set_value(LogHistory.__c.NativeFieldInfoPtr___9__42_0, IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17000249 RID: 585
		// (get) Token: 0x06000690 RID: 1680 RVA: 0x0001BE38 File Offset: 0x0001A038
		// (set) Token: 0x06000691 RID: 1681 RVA: 0x0001BE63 File Offset: 0x0001A063
		public unsafe static Action<LogHistoryItem> __9__42_1
		{
			get
			{
				IntPtr intPtr;
				IL2CPP.il2cpp_field_static_get_value(LogHistory.__c.NativeFieldInfoPtr___9__42_1, (void*)(&intPtr));
				IntPtr intPtr2 = intPtr;
				return (intPtr2 != 0) ? new Action<LogHistoryItem>(intPtr2) : null;
			}
			set
			{
				IL2CPP.il2cpp_field_static_set_value(LogHistory.__c.NativeFieldInfoPtr___9__42_1, IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x1700024A RID: 586
		// (get) Token: 0x06000692 RID: 1682 RVA: 0x0001BE78 File Offset: 0x0001A078
		// (set) Token: 0x06000693 RID: 1683 RVA: 0x0001BEA3 File Offset: 0x0001A0A3
		public unsafe static Action __9__42_2
		{
			get
			{
				IntPtr intPtr;
				IL2CPP.il2cpp_field_static_get_value(LogHistory.__c.NativeFieldInfoPtr___9__42_2, (void*)(&intPtr));
				IntPtr intPtr2 = intPtr;
				return (intPtr2 != 0) ? new Action(intPtr2) : null;
			}
			set
			{
				IL2CPP.il2cpp_field_static_set_value(LogHistory.__c.NativeFieldInfoPtr___9__42_2, IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x04000405 RID: 1029
		private static readonly IntPtr NativeFieldInfoPtr___9;

		// Token: 0x04000406 RID: 1030
		private static readonly IntPtr NativeFieldInfoPtr___9__42_0;

		// Token: 0x04000407 RID: 1031
		private static readonly IntPtr NativeFieldInfoPtr___9__42_1;

		// Token: 0x04000408 RID: 1032
		private static readonly IntPtr NativeFieldInfoPtr___9__42_2;

		// Token: 0x04000409 RID: 1033
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

		// Token: 0x0400040A RID: 1034
		private static readonly IntPtr NativeMethodInfoPtr___ctor_b__42_0_Internal_Void_LogHistoryItem_0;

		// Token: 0x0400040B RID: 1035
		private static readonly IntPtr NativeMethodInfoPtr___ctor_b__42_1_Internal_Void_LogHistoryItem_0;

		// Token: 0x0400040C RID: 1036
		private static readonly IntPtr NativeMethodInfoPtr___ctor_b__42_2_Internal_Void_0;
	}

	// Token: 0x02000040 RID: 64
	private sealed class MethodInfoStoreGeneric_GetSubArray_Private_Il2CppArrayBase_1_T_Il2CppArrayBase_1_T_Int32_Int32_0<T>
	{
		// Token: 0x0400040D RID: 1037
		internal static IntPtr Pointer = IL2CPP.il2cpp_method_get_from_reflection(IL2CPP.Il2CppObjectBaseToPtrNotNull(new MethodInfo(IL2CPP.il2cpp_method_get_object(LogHistory.NativeMethodInfoPtr_GetSubArray_Private_Il2CppArrayBase_1_T_Il2CppArrayBase_1_T_Int32_Int32_0, Il2CppClassPointerStore<LogHistory>.NativeClassPtr)).MakeGenericMethod(new Il2CppReferenceArray<Type>(new Type[] { Type.internal_from_handle(IL2CPP.il2cpp_class_get_type(Il2CppClassPointerStore<T>.NativeClassPtr)) }))));
	}
}
