m

mscorlib/System/Runtime/CompilerServices/AsyncMethodBuilderCore.cs

@@ -0,0 +1,150 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Threading;
+using System.Threading.Tasks;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	// Token: 0x02000553 RID: 1363
+	[Token(Token = "0x2000553")]
+	internal struct AsyncMethodBuilderCore
+	{
+		// Token: 0x06002C27 RID: 11303 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C27")]
+		[Address(RVA = "0x2CE8320", Offset = "0x2CE7320", VA = "0x182CE8320")]
+		public void SetStateMachine(IAsyncStateMachine stateMachine)
+		{
+		}
+
+		// Token: 0x06002C28 RID: 11304 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002C28")]
+		[Address(RVA = "0x2CE7EA0", Offset = "0x2CE6EA0", VA = "0x182CE7EA0")]
+		internal Action GetCompletionAction(Task taskForTracing, ref AsyncMethodBuilderCore.MoveNextRunner runnerToInitialize)
+		{
+			return null;
+		}
+
+		// Token: 0x06002C29 RID: 11305 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002C29")]
+		[Address(RVA = "0x2CE8040", Offset = "0x2CE7040", VA = "0x182CE8040")]
+		private Action OutputAsyncCausalityEvents(Task innerTask, Action continuation)
+		{
+			return null;
+		}
+
+		// Token: 0x06002C2A RID: 11306 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C2A")]
+		[Address(RVA = "0x2CE81C0", Offset = "0x2CE71C0", VA = "0x182CE81C0")]
+		internal void PostBoxInitialization(IAsyncStateMachine stateMachine, AsyncMethodBuilderCore.MoveNextRunner runner, Task builtTask)
+		{
+		}
+
+		// Token: 0x06002C2B RID: 11307 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C2B")]
+		[Address(RVA = "0x2CE83E0", Offset = "0x2CE73E0", VA = "0x182CE83E0")]
+		internal static void ThrowAsync(Exception exception, SynchronizationContext targetContext)
+		{
+		}
+
+		// Token: 0x06002C2C RID: 11308 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002C2C")]
+		[Address(RVA = "0x2CE7D90", Offset = "0x2CE6D90", VA = "0x182CE7D90")]
+		internal static Action CreateContinuationWrapper(Action continuation, Action invokeAction, [Optional] Task innerTask)
+		{
+			return null;
+		}
+
+		// Token: 0x06002C2D RID: 11309 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002C2D")]
+		[Address(RVA = "0x2CE8650", Offset = "0x2CE7650", VA = "0x182CE8650")]
+		internal static Task TryGetContinuationTask(Action action)
+		{
+			return null;
+		}
+
+		// Token: 0x04001936 RID: 6454
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x4001936")]
+		internal IAsyncStateMachine m_stateMachine;
+
+		// Token: 0x04001937 RID: 6455
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x8")]
+		[Token(Token = "0x4001937")]
+		internal Action m_defaultContextAction;
+
+		// Token: 0x02000554 RID: 1364
+		[Token(Token = "0x2000554")]
+		internal sealed class MoveNextRunner
+		{
+			// Token: 0x06002C2E RID: 11310 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6002C2E")]
+			[Address(RVA = "0x417DD0", Offset = "0x416DD0", VA = "0x180417DD0")]
+			internal MoveNextRunner(ExecutionContext context, IAsyncStateMachine stateMachine)
+			{
+			}
+
+			// Token: 0x06002C2F RID: 11311 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6002C2F")]
+			[Address(RVA = "0x2CF3A60", Offset = "0x2CF2A60", VA = "0x182CF3A60")]
+			internal void Run()
+			{
+			}
+
+			// Token: 0x06002C30 RID: 11312 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6002C30")]
+			[Address(RVA = "0x2CF39C0", Offset = "0x2CF29C0", VA = "0x182CF39C0")]
+			private static void InvokeMoveNext(object stateMachine)
+			{
+			}
+
+			// Token: 0x04001938 RID: 6456
+			[global::Cpp2IlInjected.FieldOffset(Offset = "0x10")]
+			[Token(Token = "0x4001938")]
+			private readonly ExecutionContext m_context;
+
+			// Token: 0x04001939 RID: 6457
+			[global::Cpp2IlInjected.FieldOffset(Offset = "0x18")]
+			[Token(Token = "0x4001939")]
+			internal IAsyncStateMachine m_stateMachine;
+
+			// Token: 0x0400193A RID: 6458
+			[Token(Token = "0x400193A")]
+			private static ContextCallback s_invokeMoveNext;
+		}
+
+		// Token: 0x02000555 RID: 1365
+		[Token(Token = "0x2000555")]
+		private class ContinuationWrapper
+		{
+			// Token: 0x06002C31 RID: 11313 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6002C31")]
+			[Address(RVA = "0x2CEC680", Offset = "0x2CEB680", VA = "0x182CEC680")]
+			internal ContinuationWrapper(Action continuation, Action invokeAction, Task innerTask)
+			{
+			}
+
+			// Token: 0x06002C32 RID: 11314 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6002C32")]
+			[Address(RVA = "0x5F4B30", Offset = "0x5F3B30", VA = "0x1805F4B30")]
+			internal void Invoke()
+			{
+			}
+
+			// Token: 0x0400193B RID: 6459
+			[global::Cpp2IlInjected.FieldOffset(Offset = "0x10")]
+			[Token(Token = "0x400193B")]
+			internal readonly Action m_continuation;
+
+			// Token: 0x0400193C RID: 6460
+			[global::Cpp2IlInjected.FieldOffset(Offset = "0x18")]
+			[Token(Token = "0x400193C")]
+			private readonly Action m_invokeAction;
+
+			// Token: 0x0400193D RID: 6461
+			[global::Cpp2IlInjected.FieldOffset(Offset = "0x20")]
+			[Token(Token = "0x400193D")]
+			internal readonly Task m_innerTask;
+		}
+	}
+}

mscorlib/System/Runtime/CompilerServices/AsyncStateMachineAttribute.cs

@@ -0,0 +1,22 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Indicates whether a method is marked with either the Async or async modifier.</summary>
+	// Token: 0x02000558 RID: 1368
+	[Token(Token = "0x2000558")]
+	[AttributeUsage(AttributeTargets.Method)]
+	[Serializable]
+	public sealed class AsyncStateMachineAttribute : StateMachineAttribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.CompilerServices.AsyncStateMachineAttribute" /> class.</summary>
+		/// <param name="stateMachineType">The type object for the underlying state machine type that's used to implement a state machine method.</param>
+		// Token: 0x06002C39 RID: 11321 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C39")]
+		[Address(RVA = "0x681CA0", Offset = "0x680CA0", VA = "0x180681CA0")]
+		public AsyncStateMachineAttribute(Type stateMachineType)
+		{
+		}
+	}
+}

mscorlib/System/Runtime/CompilerServices/AsyncTaskCache.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Threading.Tasks;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	// Token: 0x02000552 RID: 1362
+	[Token(Token = "0x2000552")]
+	internal static class AsyncTaskCache
+	{
+		// Token: 0x06002C24 RID: 11300 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002C24")]
+		[Address(RVA = "0x2CE86E0", Offset = "0x2CE76E0", VA = "0x182CE86E0")]
+		private static Task<int>[] CreateInt32Tasks()
+		{
+			return null;
+		}
+
+		// Token: 0x06002C25 RID: 11301 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002C25")]
+		[Address(RVA = "0x25EBDC0", Offset = "0x25EADC0", VA = "0x1825EBDC0")]
+		internal static Task<TResult> CreateCacheableTask<TResult>(TResult result)
+		{
+			return null;
+		}
+
+		// Token: 0x04001933 RID: 6451
+		[Token(Token = "0x4001933")]
+		internal static readonly Task<bool> TrueTask;
+
+		// Token: 0x04001934 RID: 6452
+		[Token(Token = "0x4001934")]
+		internal static readonly Task<bool> FalseTask;
+
+		// Token: 0x04001935 RID: 6453
+		[Token(Token = "0x4001935")]
+		internal static readonly Task<int>[] Int32Tasks;
+	}
+}

mscorlib/System/Runtime/CompilerServices/AsyncTaskMethodBuilder.2.cs

@@ -0,0 +1,139 @@
+using System;
+using System.Diagnostics;
+using System.Threading.Tasks;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Represents a builder for asynchronous methods that returns a task and provides a parameter for the result.</summary>
+	/// <typeparam name="TResult">The result to use to complete the task.</typeparam>
+	// Token: 0x02000551 RID: 1361
+	[Token(Token = "0x2000551")]
+	public struct AsyncTaskMethodBuilder<TResult>
+	{
+		/// <summary>Creates an instance of the <see cref="T:System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1" /> class.</summary>
+		/// <returns>A new instance of the builder.</returns>
+		// Token: 0x06002C19 RID: 11289 RVA: 0x00018BD0 File Offset: 0x00016DD0
+		[Token(Token = "0x6002C19")]
+		[Address(RVA = "0x437C30", Offset = "0x436C30", VA = "0x180437C30")]
+		public static AsyncTaskMethodBuilder<TResult> Create()
+		{
+			return default(AsyncTaskMethodBuilder<TResult>);
+		}
+
+		/// <summary>Begins running the builder with the associated state machine.</summary>
+		/// <param name="stateMachine">The state machine instance, passed by reference.</param>
+		/// <typeparam name="TStateMachine">The type of the state machine.</typeparam>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="stateMachine" /> is <see langword="null" />.</exception>
+		// Token: 0x06002C1A RID: 11290 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C1A")]
+		[Address(RVA = "0x2505880", Offset = "0x2504880", VA = "0x182505880")]
+		[DebuggerStepThrough]
+		public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine
+		{
+		}
+
+		/// <summary>Associates the builder with the specified state machine.</summary>
+		/// <param name="stateMachine">The state machine instance to associate with the builder.</param>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="stateMachine" /> is <see langword="null" />.</exception>
+		/// <exception cref="T:System.InvalidOperationException">The state machine was previously set.</exception>
+		// Token: 0x06002C1B RID: 11291 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C1B")]
+		[Address(RVA = "0x2F2CA10", Offset = "0x2F2BA10", VA = "0x182F2CA10")]
+		public void SetStateMachine(IAsyncStateMachine stateMachine)
+		{
+		}
+
+		/// <summary>Schedules the state machine to proceed to the next action when the specified awaiter completes.</summary>
+		/// <param name="awaiter">The awaiter.</param>
+		/// <param name="stateMachine">The state machine.</param>
+		/// <typeparam name="TAwaiter">The type of the awaiter.</typeparam>
+		/// <typeparam name="TStateMachine">The type of the state machine.</typeparam>
+		// Token: 0x06002C1C RID: 11292 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C1C")]
+		[Address(RVA = "0x24FF470", Offset = "0x24FE470", VA = "0x1824FF470")]
+		public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine
+		{
+		}
+
+		/// <summary>Schedules the state machine to proceed to the next action when the specified awaiter completes. This method can be called from partially trusted code.</summary>
+		/// <param name="awaiter">The awaiter.</param>
+		/// <param name="stateMachine">The state machine.</param>
+		/// <typeparam name="TAwaiter">The type of the awaiter.</typeparam>
+		/// <typeparam name="TStateMachine">The type of the state machine.</typeparam>
+		// Token: 0x06002C1D RID: 11293 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C1D")]
+		[Address(RVA = "0x2503CF0", Offset = "0x2502CF0", VA = "0x182503CF0")]
+		public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine
+		{
+		}
+
+		/// <summary>Gets the task for this builder.</summary>
+		/// <returns>The task for this builder.</returns>
+		// Token: 0x170006B4 RID: 1716
+		// (get) Token: 0x06002C1E RID: 11294 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x170006B4")]
+		public Task<TResult> Task
+		{
+			[Token(Token = "0x6002C1E")]
+			[Address(RVA = "0x2F2D490", Offset = "0x2F2C490", VA = "0x182F2D490")]
+			get
+			{
+				return null;
+			}
+		}
+
+		/// <summary>Marks the task as successfully completed.</summary>
+		/// <param name="result">The result to use to complete the task.</param>
+		/// <exception cref="T:System.InvalidOperationException">The task has already completed.</exception>
+		// Token: 0x06002C1F RID: 11295 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C1F")]
+		[Address(RVA = "0x2F2B760", Offset = "0x2F2A760", VA = "0x182F2B760")]
+		public void SetResult(TResult result)
+		{
+		}
+
+		// Token: 0x06002C20 RID: 11296 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C20")]
+		[Address(RVA = "0x2F2B950", Offset = "0x2F2A950", VA = "0x182F2B950")]
+		internal void SetResult(Task<TResult> completedTask)
+		{
+		}
+
+		/// <summary>Marks the task as failed and binds the specified exception to the task.</summary>
+		/// <param name="exception">The exception to bind to the task.</param>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="exception" /> is <see langword="null" />.</exception>
+		/// <exception cref="T:System.InvalidOperationException">The task has already completed.</exception>
+		// Token: 0x06002C21 RID: 11297 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C21")]
+		[Address(RVA = "0x2F2ACD0", Offset = "0x2F29CD0", VA = "0x182F2ACD0")]
+		public void SetException(Exception exception)
+		{
+		}
+
+		// Token: 0x06002C22 RID: 11298 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002C22")]
+		[Address(RVA = "0x2F23860", Offset = "0x2F22860", VA = "0x182F23860")]
+		private Task<TResult> GetTaskForResult(TResult result)
+		{
+			return null;
+		}
+
+		// Token: 0x04001930 RID: 6448
+		[Token(Token = "0x4001930")]
+		internal static readonly Task<TResult> s_defaultResultTask;
+
+		// Token: 0x04001931 RID: 6449
+		[FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x4001931")]
+		private AsyncMethodBuilderCore m_coreState;
+
+		// Token: 0x04001932 RID: 6450
+		[FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x4001932")]
+		private Task<TResult> m_task;
+	}
+}

mscorlib/System/Runtime/CompilerServices/AsyncTaskMethodBuilder.cs

@@ -0,0 +1,122 @@
+using System;
+using System.Diagnostics;
+using System.Threading.Tasks;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Represents a builder for asynchronous methods that return a task.</summary>
+	// Token: 0x02000550 RID: 1360
+	[Token(Token = "0x2000550")]
+	public struct AsyncTaskMethodBuilder
+	{
+		/// <summary>Creates an instance of the <see cref="T:System.Runtime.CompilerServices.AsyncTaskMethodBuilder" /> class.</summary>
+		/// <returns>A new instance of the builder.</returns>
+		// Token: 0x06002C10 RID: 11280 RVA: 0x00018BB8 File Offset: 0x00016DB8
+		[Token(Token = "0x6002C10")]
+		[Address(RVA = "0x437C30", Offset = "0x436C30", VA = "0x180437C30")]
+		public static AsyncTaskMethodBuilder Create()
+		{
+			return default(AsyncTaskMethodBuilder);
+		}
+
+		/// <summary>Begins running the builder with the associated state machine.</summary>
+		/// <param name="stateMachine">The state machine instance, passed by reference.</param>
+		/// <typeparam name="TStateMachine">The type of the state machine.</typeparam>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="stateMachine" /> is <see langword="null" />.</exception>
+		// Token: 0x06002C11 RID: 11281 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C11")]
+		[Address(RVA = "0x2507FE0", Offset = "0x2506FE0", VA = "0x182507FE0")]
+		[DebuggerStepThrough]
+		public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine
+		{
+		}
+
+		/// <summary>Associates the builder with the specified state machine.</summary>
+		/// <param name="stateMachine">The state machine instance to associate with the builder.</param>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="stateMachine" /> is <see langword="null" />.</exception>
+		/// <exception cref="T:System.InvalidOperationException">The state machine was previously set.</exception>
+		// Token: 0x06002C12 RID: 11282 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C12")]
+		[Address(RVA = "0x2CE89A0", Offset = "0x2CE79A0", VA = "0x182CE89A0")]
+		public void SetStateMachine(IAsyncStateMachine stateMachine)
+		{
+		}
+
+		/// <summary>Schedules the state machine to proceed to the next action when the specified awaiter completes.</summary>
+		/// <param name="awaiter">The awaiter.</param>
+		/// <param name="stateMachine">The state machine.</param>
+		/// <typeparam name="TAwaiter">The type of the awaiter.</typeparam>
+		/// <typeparam name="TStateMachine">The type of the state machine.</typeparam>
+		// Token: 0x06002C13 RID: 11283 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C13")]
+		[Address(RVA = "0x2505B30", Offset = "0x2504B30", VA = "0x182505B30")]
+		public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine
+		{
+		}
+
+		/// <summary>Schedules the state machine to proceed to the next action when the specified awaiter completes. This method can be called from partially trusted code.</summary>
+		/// <param name="awaiter">The awaiter.</param>
+		/// <param name="stateMachine">The state machine.</param>
+		/// <typeparam name="TAwaiter">The type of the awaiter.</typeparam>
+		/// <typeparam name="TStateMachine">The type of the state machine.</typeparam>
+		// Token: 0x06002C14 RID: 11284 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C14")]
+		[Address(RVA = "0x2505C50", Offset = "0x2504C50", VA = "0x182505C50")]
+		public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine
+		{
+		}
+
+		/// <summary>Gets the task for this builder.</summary>
+		/// <returns>The task for this builder.</returns>
+		/// <exception cref="T:System.InvalidOperationException">The builder is not initialized.</exception>
+		// Token: 0x170006B3 RID: 1715
+		// (get) Token: 0x06002C15 RID: 11285 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x170006B3")]
+		public Task Task
+		{
+			[Token(Token = "0x6002C15")]
+			[Address(RVA = "0x2CE8A60", Offset = "0x2CE7A60", VA = "0x182CE8A60")]
+			get
+			{
+				return null;
+			}
+		}
+
+		/// <summary>Marks the task as successfully completed.</summary>
+		/// <exception cref="T:System.InvalidOperationException">The task has already completed.  
+		///  -or-  
+		///  The builder is not initialized.</exception>
+		// Token: 0x06002C16 RID: 11286 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C16")]
+		[Address(RVA = "0x2CE8930", Offset = "0x2CE7930", VA = "0x182CE8930")]
+		public void SetResult()
+		{
+		}
+
+		/// <summary>Marks the task as failed and binds the specified exception to the task.</summary>
+		/// <param name="exception">The exception to bind to the task.</param>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="exception" /> is <see langword="null" />.</exception>
+		/// <exception cref="T:System.InvalidOperationException">The task has already completed.  
+		///  -or-  
+		///  The builder is not initialized.</exception>
+		// Token: 0x06002C17 RID: 11287 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C17")]
+		[Address(RVA = "0x2CE88E0", Offset = "0x2CE78E0", VA = "0x182CE88E0")]
+		public void SetException(Exception exception)
+		{
+		}
+
+		// Token: 0x0400192E RID: 6446
+		[Token(Token = "0x400192E")]
+		private static readonly Task<VoidTaskResult> s_cachedCompleted;
+
+		// Token: 0x0400192F RID: 6447
+		[FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x400192F")]
+		private AsyncTaskMethodBuilder<VoidTaskResult> m_builder;
+	}
+}

mscorlib/System/Runtime/CompilerServices/AsyncVoidMethodBuilder.cs

@@ -0,0 +1,117 @@
+using System;
+using System.Diagnostics;
+using System.Threading;
+using System.Threading.Tasks;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Represents a builder for asynchronous methods that do not return a value.</summary>
+	// Token: 0x0200054F RID: 1359
+	[Token(Token = "0x200054F")]
+	public struct AsyncVoidMethodBuilder
+	{
+		/// <summary>Creates an instance of the <see cref="T:System.Runtime.CompilerServices.AsyncVoidMethodBuilder" /> class.</summary>
+		/// <returns>A new instance of the builder.</returns>
+		// Token: 0x06002C08 RID: 11272 RVA: 0x00018BA0 File Offset: 0x00016DA0
+		[Token(Token = "0x6002C08")]
+		[Address(RVA = "0x2CE8AA0", Offset = "0x2CE7AA0", VA = "0x182CE8AA0")]
+		public static AsyncVoidMethodBuilder Create()
+		{
+			return default(AsyncVoidMethodBuilder);
+		}
+
+		/// <summary>Begins running the builder with the associated state machine.</summary>
+		/// <param name="stateMachine">The state machine instance, passed by reference.</param>
+		/// <typeparam name="TStateMachine">The type of the state machine.</typeparam>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="stateMachine" /> is <see langword="null" />.</exception>
+		// Token: 0x06002C09 RID: 11273 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C09")]
+		[Address(RVA = "0x2A3B9E0", Offset = "0x2A3A9E0", VA = "0x182A3B9E0")]
+		[DebuggerStepThrough]
+		public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine
+		{
+		}
+
+		/// <summary>Associates the builder with the specified state machine.</summary>
+		/// <param name="stateMachine">The state machine instance to associate with the builder.</param>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="stateMachine" /> is <see langword="null" />.</exception>
+		/// <exception cref="T:System.InvalidOperationException">The state machine was previously set.</exception>
+		// Token: 0x06002C0A RID: 11274 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C0A")]
+		[Address(RVA = "0x2CE8D90", Offset = "0x2CE7D90", VA = "0x182CE8D90")]
+		public void SetStateMachine(IAsyncStateMachine stateMachine)
+		{
+		}
+
+		/// <summary>Schedules the state machine to proceed to the next action when the specified awaiter completes. This method can be called from partially trusted code.</summary>
+		/// <param name="awaiter">The awaiter.</param>
+		/// <param name="stateMachine">The state machine.</param>
+		/// <typeparam name="TAwaiter">The type of the awaiter.</typeparam>
+		/// <typeparam name="TStateMachine">The type of the state machine.</typeparam>
+		// Token: 0x06002C0B RID: 11275 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C0B")]
+		[Address(RVA = "0x2A36230", Offset = "0x2A35230", VA = "0x182A36230")]
+		public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine
+		{
+		}
+
+		/// <summary>Marks the method builder as successfully completed.</summary>
+		/// <exception cref="T:System.InvalidOperationException">The builder is not initialized.</exception>
+		// Token: 0x06002C0C RID: 11276 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C0C")]
+		[Address(RVA = "0x2CE8CF0", Offset = "0x2CE7CF0", VA = "0x182CE8CF0")]
+		public void SetResult()
+		{
+		}
+
+		/// <summary>Binds an exception to the method builder.</summary>
+		/// <param name="exception">The exception to bind.</param>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="exception" /> is <see langword="null" />.</exception>
+		/// <exception cref="T:System.InvalidOperationException">The builder is not initialized.</exception>
+		// Token: 0x06002C0D RID: 11277 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C0D")]
+		[Address(RVA = "0x2CE8B90", Offset = "0x2CE7B90", VA = "0x182CE8B90")]
+		public void SetException(Exception exception)
+		{
+		}
+
+		// Token: 0x06002C0E RID: 11278 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C0E")]
+		[Address(RVA = "0x2CE8B10", Offset = "0x2CE7B10", VA = "0x182CE8B10")]
+		private void NotifySynchronizationContextOfCompletion()
+		{
+		}
+
+		// Token: 0x170006B2 RID: 1714
+		// (get) Token: 0x06002C0F RID: 11279 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x170006B2")]
+		private Task Task
+		{
+			[Token(Token = "0x6002C0F")]
+			[Address(RVA = "0x2CE8DA0", Offset = "0x2CE7DA0", VA = "0x182CE8DA0")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x0400192B RID: 6443
+		[FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x400192B")]
+		private SynchronizationContext m_synchronizationContext;
+
+		// Token: 0x0400192C RID: 6444
+		[FieldOffset(Offset = "0x8")]
+		[Token(Token = "0x400192C")]
+		private AsyncMethodBuilderCore m_coreState;
+
+		// Token: 0x0400192D RID: 6445
+		[FieldOffset(Offset = "0x18")]
+		[Token(Token = "0x400192D")]
+		private Task m_task;
+	}
+}

mscorlib/System/Runtime/CompilerServices/CallerFilePathAttribute.cs

@@ -0,0 +1,20 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Allows you to obtain the full path of the source file that contains the caller. This is the file path at the time of compile.</summary>
+	// Token: 0x02000559 RID: 1369
+	[Token(Token = "0x2000559")]
+	[AttributeUsage(AttributeTargets.Parameter)]
+	public sealed class CallerFilePathAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.CompilerServices.CallerFilePathAttribute" /> class.</summary>
+		// Token: 0x06002C3A RID: 11322 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C3A")]
+		[Address(RVA = "0x42BA20", Offset = "0x42AA20", VA = "0x18042BA20")]
+		public CallerFilePathAttribute()
+		{
+		}
+	}
+}

mscorlib/System/Runtime/CompilerServices/CallerLineNumberAttribute.cs

@@ -0,0 +1,20 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Allows you to obtain the line number in the source file at which the method is called.</summary>
+	// Token: 0x0200055A RID: 1370
+	[Token(Token = "0x200055A")]
+	[AttributeUsage(AttributeTargets.Parameter)]
+	public sealed class CallerLineNumberAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.CompilerServices.CallerLineNumberAttribute" /> class.</summary>
+		// Token: 0x06002C3B RID: 11323 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C3B")]
+		[Address(RVA = "0x42BA20", Offset = "0x42AA20", VA = "0x18042BA20")]
+		public CallerLineNumberAttribute()
+		{
+		}
+	}
+}

mscorlib/System/Runtime/CompilerServices/CallerMemberNameAttribute.cs

@@ -0,0 +1,20 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Allows you to obtain the method or property name of the caller to the method.</summary>
+	// Token: 0x0200055B RID: 1371
+	[Token(Token = "0x200055B")]
+	[AttributeUsage(AttributeTargets.Parameter)]
+	public sealed class CallerMemberNameAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.CompilerServices.CallerMemberNameAttribute" /> class.</summary>
+		// Token: 0x06002C3C RID: 11324 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C3C")]
+		[Address(RVA = "0x42BA20", Offset = "0x42AA20", VA = "0x18042BA20")]
+		public CallerMemberNameAttribute()
+		{
+		}
+	}
+}

mscorlib/System/Runtime/CompilerServices/CompilationRelaxations.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Runtime.InteropServices;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Specifies parameters that control the strictness of the code generated by the common language runtime's just-in-time (JIT) compiler.</summary>
+	// Token: 0x0200056F RID: 1391
+	[Token(Token = "0x200056F")]
+	[Flags]
+	[ComVisible(true)]
+	[Serializable]
+	public enum CompilationRelaxations
+	{
+		/// <summary>Marks an assembly as not requiring string-literal interning.</summary>
+		// Token: 0x04001959 RID: 6489
+		[Token(Token = "0x4001959")]
+		NoStringInterning = 8
+	}
+}

mscorlib/System/Runtime/CompilerServices/CompilationRelaxationsAttribute.cs

@@ -0,0 +1,54 @@
+using System;
+using System.Runtime.InteropServices;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Controls the strictness of the code generated by the common language runtime's just-in-time (JIT) compiler.</summary>
+	// Token: 0x02000570 RID: 1392
+	[Token(Token = "0x2000570")]
+	[ComVisible(true)]
+	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Method)]
+	[Serializable]
+	public class CompilationRelaxationsAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.CompilerServices.CompilationRelaxationsAttribute" /> class with the specified compilation relaxations.</summary>
+		/// <param name="relaxations">The compilation relaxations.</param>
+		// Token: 0x06002C73 RID: 11379 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C73")]
+		[Address(RVA = "0x41F8E0", Offset = "0x41E8E0", VA = "0x18041F8E0")]
+		public CompilationRelaxationsAttribute(int relaxations)
+		{
+		}
+
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.CompilerServices.CompilationRelaxationsAttribute" /> class with the specified <see cref="T:System.Runtime.CompilerServices.CompilationRelaxations" /> value.</summary>
+		/// <param name="relaxations">One of the <see cref="T:System.Runtime.CompilerServices.CompilationRelaxations" /> values.</param>
+		// Token: 0x06002C74 RID: 11380 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C74")]
+		[Address(RVA = "0x41F8E0", Offset = "0x41E8E0", VA = "0x18041F8E0")]
+		public CompilationRelaxationsAttribute(CompilationRelaxations relaxations)
+		{
+		}
+
+		/// <summary>Gets the compilation relaxations specified when the current object was constructed.</summary>
+		/// <returns>The compilation relaxations specified when the current object was constructed.  
+		///  Use the <see cref="T:System.Runtime.CompilerServices.CompilationRelaxations" /> enumeration with the <see cref="P:System.Runtime.CompilerServices.CompilationRelaxationsAttribute.CompilationRelaxations" /> property.</returns>
+		// Token: 0x170006BE RID: 1726
+		// (get) Token: 0x06002C75 RID: 11381 RVA: 0x00018CA8 File Offset: 0x00016EA8
+		[Token(Token = "0x170006BE")]
+		public int CompilationRelaxations
+		{
+			[Token(Token = "0x6002C75")]
+			[Address(RVA = "0x40F000", Offset = "0x40E000", VA = "0x18040F000")]
+			get
+			{
+				return 0;
+			}
+		}
+
+		// Token: 0x0400195A RID: 6490
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x400195A")]
+		private int m_relaxations;
+	}
+}

mscorlib/System/Runtime/CompilerServices/CompilerGeneratedAttribute.cs

@@ -0,0 +1,21 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Distinguishes a compiler-generated element from a user-generated element. This class cannot be inherited.</summary>
+	// Token: 0x02000571 RID: 1393
+	[Token(Token = "0x2000571")]
+	[AttributeUsage(AttributeTargets.All)]
+	[Serializable]
+	public sealed class CompilerGeneratedAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.CompilerServices.CompilerGeneratedAttribute" /> class.</summary>
+		// Token: 0x06002C76 RID: 11382 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C76")]
+		[Address(RVA = "0x42BA20", Offset = "0x42AA20", VA = "0x18042BA20")]
+		public CompilerGeneratedAttribute()
+		{
+		}
+	}
+}

mscorlib/System/Runtime/CompilerServices/ConditionalWeakTable.cs

@@ -0,0 +1,148 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Enables compilers to dynamically attach object fields to managed objects.</summary>
+	/// <typeparam name="TKey">The reference type to which the field is attached.</typeparam>
+	/// <typeparam name="TValue">The field's type. This must be a reference type.</typeparam>
+	// Token: 0x02000580 RID: 1408
+	[Token(Token = "0x2000580")]
+	public sealed class ConditionalWeakTable<TKey, TValue> where TKey : class where TValue : class
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.CompilerServices.ConditionalWeakTable`2" /> class.</summary>
+		// Token: 0x06002C8C RID: 11404 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C8C")]
+		[Address(RVA = "0x2F30480", Offset = "0x2F2F480", VA = "0x182F30480")]
+		public ConditionalWeakTable()
+		{
+		}
+
+		/// <summary>Ensures that resources are freed and other cleanup operations are performed when the garbage collector reclaims the <see cref="T:System.Runtime.CompilerServices.ConditionalWeakTable`2" /> object.</summary>
+		// Token: 0x06002C8D RID: 11405 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C8D")]
+		[Address(RVA = "0x2F2F6C0", Offset = "0x2F2E6C0", VA = "0x182F2F6C0", Slot = "1")]
+		protected override void Finalize()
+		{
+		}
+
+		// Token: 0x06002C8E RID: 11406 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C8E")]
+		[Address(RVA = "0x2F2F970", Offset = "0x2F2E970", VA = "0x182F2F970")]
+		private void RehashWithoutResize()
+		{
+		}
+
+		// Token: 0x06002C8F RID: 11407 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C8F")]
+		[Address(RVA = "0x2F2F900", Offset = "0x2F2E900", VA = "0x182F2F900")]
+		private void RecomputeSize()
+		{
+		}
+
+		// Token: 0x06002C90 RID: 11408 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C90")]
+		[Address(RVA = "0x2F2FBF0", Offset = "0x2F2EBF0", VA = "0x182F2FBF0")]
+		private void Rehash()
+		{
+		}
+
+		/// <summary>Adds a key to the table.</summary>
+		/// <param name="key">The key to add. <paramref name="key" /> represents the object to which the property is attached.</param>
+		/// <param name="value">The key's property value.</param>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="key" /> is <see langword="null" />.</exception>
+		/// <exception cref="T:System.ArgumentException">
+		///   <paramref name="key" /> already exists.</exception>
+		// Token: 0x06002C91 RID: 11409 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C91")]
+		[Address(RVA = "0x2F2F3E0", Offset = "0x2F2E3E0", VA = "0x182F2F3E0")]
+		public void Add(TKey key, TValue value)
+		{
+		}
+
+		/// <summary>Removes a key and its value from the table.</summary>
+		/// <param name="key">The key to remove.</param>
+		/// <returns>
+		///   <see langword="true" /> if the key is found and removed; otherwise, <see langword="false" />.</returns>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="key" /> is <see langword="null" />.</exception>
+		// Token: 0x06002C92 RID: 11410 RVA: 0x00018D38 File Offset: 0x00016F38
+		[Token(Token = "0x6002C92")]
+		[Address(RVA = "0x2F2FF20", Offset = "0x2F2EF20", VA = "0x182F2FF20")]
+		public bool Remove(TKey key)
+		{
+			return default(bool);
+		}
+
+		/// <summary>Gets the value of the specified key.</summary>
+		/// <param name="key">The key that represents an object with an attached property.</param>
+		/// <param name="value">When this method returns, contains the attached property value. If <paramref name="key" /> is not found, <paramref name="value" /> contains the default value.</param>
+		/// <returns>
+		///   <see langword="true" /> if <paramref name="key" /> is found; otherwise, <see langword="false" />.</returns>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="key" /> is <see langword="null" />.</exception>
+		// Token: 0x06002C93 RID: 11411 RVA: 0x00018D50 File Offset: 0x00016F50
+		[Token(Token = "0x6002C93")]
+		[Address(RVA = "0x2F301C0", Offset = "0x2F2F1C0", VA = "0x182F301C0")]
+		public bool TryGetValue(TKey key, out TValue value)
+		{
+			return default(bool);
+		}
+
+		/// <summary>Atomically searches for a specified key in the table and returns the corresponding value. If the key does not exist in the table, the method invokes a callback method to create a value that is bound to the specified key.</summary>
+		/// <param name="key">The key to search for. <paramref name="key" /> represents the object to which the property is attached.</param>
+		/// <param name="createValueCallback">A delegate to a method that can create a value for the given <paramref name="key" />. It has a single parameter of type TKey, and returns a value of type TValue.</param>
+		/// <returns>The value attached to <paramref name="key" />, if <paramref name="key" /> already exists in the table; otherwise, the new value returned by the <paramref name="createValueCallback" /> delegate.</returns>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="key" /> or <paramref name="createValueCallback" /> is <see langword="null" />.</exception>
+		// Token: 0x06002C94 RID: 11412 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002C94")]
+		[Address(RVA = "0x2F2F730", Offset = "0x2F2E730", VA = "0x182F2F730")]
+		public TValue GetValue(TKey key, ConditionalWeakTable<TKey, TValue>.CreateValueCallback createValueCallback)
+		{
+			return null;
+		}
+
+		// Token: 0x04001964 RID: 6500
+		[Token(Token = "0x4001964")]
+		private const int INITIAL_SIZE = 13;
+
+		// Token: 0x04001965 RID: 6501
+		[Token(Token = "0x4001965")]
+		private const float LOAD_FACTOR = 0.7f;
+
+		// Token: 0x04001966 RID: 6502
+		[Token(Token = "0x4001966")]
+		private const float COMPACT_FACTOR = 0.5f;
+
+		// Token: 0x04001967 RID: 6503
+		[Token(Token = "0x4001967")]
+		private const float EXPAND_FACTOR = 1.1f;
+
+		// Token: 0x04001968 RID: 6504
+		[FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x4001968")]
+		private Ephemeron[] data;
+
+		// Token: 0x04001969 RID: 6505
+		[FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x4001969")]
+		private object _lock;
+
+		// Token: 0x0400196A RID: 6506
+		[FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x400196A")]
+		private int size;
+
+		/// <summary>Represents a method that creates a non-default value to add as part of a key/value pair to a <see cref="T:System.Runtime.CompilerServices.ConditionalWeakTable`2" /> object.</summary>
+		/// <param name="key">The key that belongs to the value to create.</param>
+		/// <typeparam name="TKey" />
+		/// <typeparam name="TValue" />
+		/// <returns>An instance of a reference type that represents the value to attach to the specified key.</returns>
+		// Token: 0x02000581 RID: 1409
+		// (Invoke) Token: 0x06002C96 RID: 11414
+		[Token(Token = "0x2000581")]
+		public delegate TValue CreateValueCallback(TKey key);
+	}
+}

mscorlib/System/Runtime/CompilerServices/ConfiguredTaskAwaitable.2.cs

@@ -0,0 +1,111 @@
+using System;
+using System.Threading.Tasks;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Provides an awaitable object that enables configured awaits on a task.</summary>
+	/// <typeparam name="TResult">The type of the result produced by this <see cref="T:System.Threading.Tasks.Task`1" />.</typeparam>
+	// Token: 0x02000567 RID: 1383
+	[Token(Token = "0x2000567")]
+	public struct ConfiguredTaskAwaitable<TResult>
+	{
+		// Token: 0x06002C60 RID: 11360 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C60")]
+		[Address(RVA = "0x2EFBA40", Offset = "0x2EFAA40", VA = "0x182EFBA40")]
+		internal ConfiguredTaskAwaitable(Task<TResult> task, bool continueOnCapturedContext)
+		{
+		}
+
+		/// <summary>Returns an awaiter for this awaitable object.</summary>
+		/// <returns>The awaiter.</returns>
+		// Token: 0x06002C61 RID: 11361 RVA: 0x00018C48 File Offset: 0x00016E48
+		[Token(Token = "0x6002C61")]
+		[Address(RVA = "0x814AC0", Offset = "0x813AC0", VA = "0x180814AC0")]
+		public ConfiguredTaskAwaitable<TResult>.ConfiguredTaskAwaiter GetAwaiter()
+		{
+			return default(ConfiguredTaskAwaitable<TResult>.ConfiguredTaskAwaiter);
+		}
+
+		// Token: 0x0400194B RID: 6475
+		[FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x400194B")]
+		private readonly ConfiguredTaskAwaitable<TResult>.ConfiguredTaskAwaiter m_configuredTaskAwaiter;
+
+		/// <summary>Provides an awaiter for an awaitable object(<see cref="T:System.Runtime.CompilerServices.ConfiguredTaskAwaitable`1" />).</summary>
+		/// <typeparam name="TResult" />
+		// Token: 0x02000568 RID: 1384
+		[Token(Token = "0x2000568")]
+		public struct ConfiguredTaskAwaiter : ICriticalNotifyCompletion, INotifyCompletion
+		{
+			// Token: 0x06002C62 RID: 11362 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6002C62")]
+			[Address(RVA = "0x9E9670", Offset = "0x9E8670", VA = "0x1809E9670")]
+			internal ConfiguredTaskAwaiter(Task<TResult> task, bool continueOnCapturedContext)
+			{
+			}
+
+			/// <summary>Gets a value that specifies whether the task being awaited has been completed.</summary>
+			/// <returns>
+			///   <see langword="true" /> if the task being awaited has been completed; otherwise, <see langword="false" />.</returns>
+			/// <exception cref="T:System.NullReferenceException">The awaiter was not properly initialized.</exception>
+			// Token: 0x170006BB RID: 1723
+			// (get) Token: 0x06002C63 RID: 11363 RVA: 0x00018C60 File Offset: 0x00016E60
+			[Token(Token = "0x170006BB")]
+			public bool IsCompleted
+			{
+				[Token(Token = "0x6002C63")]
+				[Address(RVA = "0x2CEC370", Offset = "0x2CEB370", VA = "0x182CEC370")]
+				get
+				{
+					return default(bool);
+				}
+			}
+
+			/// <summary>Schedules the continuation action for the task associated with this awaiter.</summary>
+			/// <param name="continuation">The action to invoke when the await operation completes.</param>
+			/// <exception cref="T:System.ArgumentNullException">The <paramref name="continuation" /> argument is <see langword="null" />.</exception>
+			/// <exception cref="T:System.NullReferenceException">The awaiter was not properly initialized.</exception>
+			// Token: 0x06002C64 RID: 11364 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6002C64")]
+			[Address(RVA = "0x2CEC310", Offset = "0x2CEB310", VA = "0x182CEC310", Slot = "5")]
+			public void OnCompleted(Action continuation)
+			{
+			}
+
+			/// <summary>Schedules the continuation action for the task associated with this awaiter.</summary>
+			/// <param name="continuation">The action to invoke when the await operation completes.</param>
+			/// <exception cref="T:System.ArgumentNullException">The <paramref name="continuation" /> argument is <see langword="null" />.</exception>
+			/// <exception cref="T:System.NullReferenceException">The awaiter was not properly initialized.</exception>
+			// Token: 0x06002C65 RID: 11365 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6002C65")]
+			[Address(RVA = "0x2CEC340", Offset = "0x2CEB340", VA = "0x182CEC340", Slot = "4")]
+			public void UnsafeOnCompleted(Action continuation)
+			{
+			}
+
+			/// <summary>Ends the await on the completed task.</summary>
+			/// <returns>The result of the completed task.</returns>
+			/// <exception cref="T:System.NullReferenceException">The awaiter was not properly initialized.</exception>
+			/// <exception cref="T:System.Threading.Tasks.TaskCanceledException">The task was canceled.</exception>
+			/// <exception cref="T:System.Exception">The task completed in a faulted state.</exception>
+			// Token: 0x06002C66 RID: 11366 RVA: 0x00002082 File Offset: 0x00000282
+			[Token(Token = "0x6002C66")]
+			[Address(RVA = "0x2F02CE0", Offset = "0x2F01CE0", VA = "0x182F02CE0")]
+			public TResult GetResult()
+			{
+				return null;
+			}
+
+			// Token: 0x0400194C RID: 6476
+			[FieldOffset(Offset = "0x0")]
+			[Token(Token = "0x400194C")]
+			private readonly Task<TResult> m_task;
+
+			// Token: 0x0400194D RID: 6477
+			[FieldOffset(Offset = "0x0")]
+			[Token(Token = "0x400194D")]
+			private readonly bool m_continueOnCapturedContext;
+		}
+	}
+}

mscorlib/System/Runtime/CompilerServices/ConfiguredTaskAwaitable.cs

@@ -0,0 +1,107 @@
+using System;
+using System.Threading.Tasks;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Provides an awaitable object that enables configured awaits on a task.</summary>
+	// Token: 0x02000565 RID: 1381
+	[Token(Token = "0x2000565")]
+	public struct ConfiguredTaskAwaitable
+	{
+		// Token: 0x06002C59 RID: 11353 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C59")]
+		[Address(RVA = "0x2CEC2E0", Offset = "0x2CEB2E0", VA = "0x182CEC2E0")]
+		internal ConfiguredTaskAwaitable(Task task, bool continueOnCapturedContext)
+		{
+		}
+
+		/// <summary>Returns an awaiter for this awaitable object.</summary>
+		/// <returns>The awaiter.</returns>
+		// Token: 0x06002C5A RID: 11354 RVA: 0x00018C18 File Offset: 0x00016E18
+		[Token(Token = "0x6002C5A")]
+		[Address(RVA = "0x814AC0", Offset = "0x813AC0", VA = "0x180814AC0")]
+		public ConfiguredTaskAwaitable.ConfiguredTaskAwaiter GetAwaiter()
+		{
+			return default(ConfiguredTaskAwaitable.ConfiguredTaskAwaiter);
+		}
+
+		// Token: 0x04001948 RID: 6472
+		[FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x4001948")]
+		private readonly ConfiguredTaskAwaitable.ConfiguredTaskAwaiter m_configuredTaskAwaiter;
+
+		/// <summary>Provides an awaiter for an awaitable (<see cref="T:System.Runtime.CompilerServices.ConfiguredTaskAwaitable" />) object.</summary>
+		// Token: 0x02000566 RID: 1382
+		[Token(Token = "0x2000566")]
+		public struct ConfiguredTaskAwaiter : ICriticalNotifyCompletion, INotifyCompletion
+		{
+			// Token: 0x06002C5B RID: 11355 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6002C5B")]
+			[Address(RVA = "0x9E9670", Offset = "0x9E8670", VA = "0x1809E9670")]
+			internal ConfiguredTaskAwaiter(Task task, bool continueOnCapturedContext)
+			{
+			}
+
+			/// <summary>Gets a value that specifies whether the task being awaited is completed.</summary>
+			/// <returns>
+			///   <see langword="true" /> if the task being awaited is completed; otherwise, <see langword="false" />.</returns>
+			/// <exception cref="T:System.NullReferenceException">The awaiter was not properly initialized.</exception>
+			// Token: 0x170006BA RID: 1722
+			// (get) Token: 0x06002C5C RID: 11356 RVA: 0x00018C30 File Offset: 0x00016E30
+			[Token(Token = "0x170006BA")]
+			public bool IsCompleted
+			{
+				[Token(Token = "0x6002C5C")]
+				[Address(RVA = "0x2CEC370", Offset = "0x2CEB370", VA = "0x182CEC370")]
+				get
+				{
+					return default(bool);
+				}
+			}
+
+			/// <summary>Schedules the continuation action for the task associated with this awaiter.</summary>
+			/// <param name="continuation">The action to invoke when the await operation completes.</param>
+			/// <exception cref="T:System.ArgumentNullException">The <paramref name="continuation" /> argument is <see langword="null" />.</exception>
+			/// <exception cref="T:System.NullReferenceException">The awaiter was not properly initialized.</exception>
+			// Token: 0x06002C5D RID: 11357 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6002C5D")]
+			[Address(RVA = "0x2CEC310", Offset = "0x2CEB310", VA = "0x182CEC310", Slot = "5")]
+			public void OnCompleted(Action continuation)
+			{
+			}
+
+			/// <summary>Schedules the continuation action for the task associated with this awaiter.</summary>
+			/// <param name="continuation">The action to invoke when the await operation completes.</param>
+			/// <exception cref="T:System.ArgumentNullException">The <paramref name="continuation" /> argument is <see langword="null" />.</exception>
+			/// <exception cref="T:System.NullReferenceException">The awaiter was not properly initialized.</exception>
+			// Token: 0x06002C5E RID: 11358 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6002C5E")]
+			[Address(RVA = "0x2CEC340", Offset = "0x2CEB340", VA = "0x182CEC340", Slot = "4")]
+			public void UnsafeOnCompleted(Action continuation)
+			{
+			}
+
+			/// <summary>Ends the await on the completed task.</summary>
+			/// <exception cref="T:System.NullReferenceException">The awaiter was not properly initialized.</exception>
+			/// <exception cref="T:System.Threading.Tasks.TaskCanceledException">The task was canceled.</exception>
+			/// <exception cref="T:System.Exception">The task completed in a faulted state.</exception>
+			// Token: 0x06002C5F RID: 11359 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6002C5F")]
+			[Address(RVA = "0x2CEC300", Offset = "0x2CEB300", VA = "0x182CEC300")]
+			public void GetResult()
+			{
+			}
+
+			// Token: 0x04001949 RID: 6473
+			[FieldOffset(Offset = "0x0")]
+			[Token(Token = "0x4001949")]
+			private readonly Task m_task;
+
+			// Token: 0x0400194A RID: 6474
+			[FieldOffset(Offset = "0x8")]
+			[Token(Token = "0x400194A")]
+			private readonly bool m_continueOnCapturedContext;
+		}
+	}
+}

mscorlib/System/Runtime/CompilerServices/CustomConstantAttribute.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Runtime.InteropServices;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Defines a constant value that a compiler can persist for a field or method parameter.</summary>
+	// Token: 0x02000572 RID: 1394
+	[Token(Token = "0x2000572")]
+	[AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter)]
+	[ComVisible(true)]
+	[Serializable]
+	public abstract class CustomConstantAttribute : Attribute
+	{
+		/// <summary>Gets the constant value stored by this attribute.</summary>
+		/// <returns>The constant value stored by this attribute.</returns>
+		// Token: 0x170006BF RID: 1727
+		// (get) Token: 0x06002C77 RID: 11383
+		[Token(Token = "0x170006BF")]
+		public abstract object Value
+		{
+			[Token(Token = "0x6002C77")]
+			[Address(Slot = "7")]
+			get;
+		}
+
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.CompilerServices.CustomConstantAttribute" /> class.</summary>
+		// Token: 0x06002C78 RID: 11384 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C78")]
+		[Address(RVA = "0x42BA20", Offset = "0x42AA20", VA = "0x18042BA20")]
+		protected CustomConstantAttribute()
+		{
+		}
+	}
+}

mscorlib/System/Runtime/CompilerServices/DateTimeConstantAttribute.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Runtime.InteropServices;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Persists an 8-byte <see cref="T:System.DateTime" /> constant for a field or parameter.</summary>
+	// Token: 0x02000573 RID: 1395
+	[Token(Token = "0x2000573")]
+	[AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter)]
+	[ComVisible(true)]
+	[Serializable]
+	public sealed class DateTimeConstantAttribute : CustomConstantAttribute
+	{
+		/// <summary>Gets the number of 100-nanosecond ticks that represent the date and time of this instance.</summary>
+		/// <returns>The number of 100-nanosecond ticks that represent the date and time of this instance.</returns>
+		// Token: 0x170006C0 RID: 1728
+		// (get) Token: 0x06002C79 RID: 11385 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x170006C0")]
+		public override object Value
+		{
+			[Token(Token = "0x6002C79")]
+			[Address(RVA = "0x2CED6B0", Offset = "0x2CEC6B0", VA = "0x182CED6B0", Slot = "7")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x0400195B RID: 6491
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x400195B")]
+		private DateTime date;
+	}
+}

mscorlib/System/Runtime/CompilerServices/DecimalConstantAttribute.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Runtime.InteropServices;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Stores the value of a <see cref="T:System.Decimal" /> constant in metadata. This class cannot be inherited.</summary>
+	// Token: 0x02000574 RID: 1396
+	[Token(Token = "0x2000574")]
+	[AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter)]
+	[ComVisible(true)]
+	[Serializable]
+	public sealed class DecimalConstantAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.CompilerServices.DecimalConstantAttribute" /> class with the specified unsigned integer values.</summary>
+		/// <param name="scale">The power of 10 scaling factor that indicates the number of digits to the right of the decimal point. Valid values are 0 through 28 inclusive.</param>
+		/// <param name="sign">A value of 0 indicates a positive value, and a value of 1 indicates a negative value.</param>
+		/// <param name="hi">The high 32 bits of the 96-bit <see cref="P:System.Runtime.CompilerServices.DecimalConstantAttribute.Value" />.</param>
+		/// <param name="mid">The middle 32 bits of the 96-bit <see cref="P:System.Runtime.CompilerServices.DecimalConstantAttribute.Value" />.</param>
+		/// <param name="low">The low 32 bits of the 96-bit <see cref="P:System.Runtime.CompilerServices.DecimalConstantAttribute.Value" />.</param>
+		/// <exception cref="T:System.ArgumentOutOfRangeException">
+		///   <paramref name="scale" /> &gt; 28.</exception>
+		// Token: 0x06002C7A RID: 11386 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C7A")]
+		[Address(RVA = "0x2CED700", Offset = "0x2CEC700", VA = "0x182CED700")]
+		[CLSCompliant(false)]
+		public DecimalConstantAttribute(byte scale, byte sign, uint hi, uint mid, uint low)
+		{
+		}
+
+		/// <summary>Gets the decimal constant stored in this attribute.</summary>
+		/// <returns>The decimal constant stored in this attribute.</returns>
+		// Token: 0x170006C1 RID: 1729
+		// (get) Token: 0x06002C7B RID: 11387 RVA: 0x00018CC0 File Offset: 0x00016EC0
+		[Token(Token = "0x170006C1")]
+		public decimal Value
+		{
+			[Token(Token = "0x6002C7B")]
+			[Address(RVA = "0x814AB0", Offset = "0x813AB0", VA = "0x180814AB0")]
+			get
+			{
+				return 0m;
+			}
+		}
+
+		// Token: 0x0400195C RID: 6492
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x400195C")]
+		private decimal dec;
+	}
+}

mscorlib/System/Runtime/CompilerServices/DefaultDependencyAttribute.cs

@@ -0,0 +1,27 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Provides a hint to the common language runtime (CLR) indicating how likely a dependency is to be loaded. This class is used in a dependent assembly to indicate what hint should be used when the parent does not specify the <see cref="T:System.Runtime.CompilerServices.DependencyAttribute" /> attribute.  This class cannot be inherited.</summary>
+	// Token: 0x0200056D RID: 1389
+	[Token(Token = "0x200056D")]
+	[AttributeUsage(AttributeTargets.Assembly)]
+	[Serializable]
+	public sealed class DefaultDependencyAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.CompilerServices.DefaultDependencyAttribute" /> class with the specified <see cref="T:System.Runtime.CompilerServices.LoadHint" /> binding.</summary>
+		/// <param name="loadHintArgument">One of the <see cref="T:System.Runtime.CompilerServices.LoadHint" /> values that indicates the default binding preference.</param>
+		// Token: 0x06002C71 RID: 11377 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C71")]
+		[Address(RVA = "0x41F8E0", Offset = "0x41E8E0", VA = "0x18041F8E0")]
+		public DefaultDependencyAttribute(LoadHint loadHintArgument)
+		{
+		}
+
+		// Token: 0x04001955 RID: 6485
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x4001955")]
+		private LoadHint loadHint;
+	}
+}

mscorlib/System/Runtime/CompilerServices/DependencyAttribute.cs

@@ -0,0 +1,33 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Indicates when a dependency is to be loaded by the referring assembly. This class cannot be inherited.</summary>
+	// Token: 0x0200056E RID: 1390
+	[Token(Token = "0x200056E")]
+	[AttributeUsage(AttributeTargets.Assembly)]
+	[Serializable]
+	public sealed class DependencyAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.CompilerServices.DependencyAttribute" /> class with the specified <see cref="T:System.Runtime.CompilerServices.LoadHint" /> value.</summary>
+		/// <param name="dependentAssemblyArgument">The dependent assembly to bind to.</param>
+		/// <param name="loadHintArgument">One of the <see cref="T:System.Runtime.CompilerServices.LoadHint" /> values.</param>
+		// Token: 0x06002C72 RID: 11378 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C72")]
+		[Address(RVA = "0xE66140", Offset = "0xE65140", VA = "0x180E66140")]
+		public DependencyAttribute(string dependentAssemblyArgument, LoadHint loadHintArgument)
+		{
+		}
+
+		// Token: 0x04001956 RID: 6486
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x4001956")]
+		private string dependentAssembly;
+
+		// Token: 0x04001957 RID: 6487
+		[FieldOffset(Offset = "0x18")]
+		[Token(Token = "0x4001957")]
+		private LoadHint loadHint;
+	}
+}

mscorlib/System/Runtime/CompilerServices/Ephemeron.cs

@@ -0,0 +1,20 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	// Token: 0x0200057F RID: 1407
+	[Token(Token = "0x200057F")]
+	internal struct Ephemeron
+	{
+		// Token: 0x04001962 RID: 6498
+		[FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x4001962")]
+		internal object key;
+
+		// Token: 0x04001963 RID: 6499
+		[FieldOffset(Offset = "0x8")]
+		[Token(Token = "0x4001963")]
+		internal object value;
+	}
+}

mscorlib/System/Runtime/CompilerServices/ExtensionAttribute.cs

@@ -0,0 +1,20 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Indicates that a method is an extension method, or that a class or assembly contains extension methods.</summary>
+	// Token: 0x02000575 RID: 1397
+	[Token(Token = "0x2000575")]
+	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Method)]
+	public sealed class ExtensionAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.CompilerServices.ExtensionAttribute" /> class.</summary>
+		// Token: 0x06002C7C RID: 11388 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C7C")]
+		[Address(RVA = "0x42BA20", Offset = "0x42AA20", VA = "0x18042BA20")]
+		public ExtensionAttribute()
+		{
+		}
+	}
+}

mscorlib/System/Runtime/CompilerServices/FixedBufferAttribute.cs

@@ -0,0 +1,62 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Indicates that a field should be treated as containing a fixed number of elements of the specified primitive type. This class cannot be inherited.</summary>
+	// Token: 0x02000576 RID: 1398
+	[Token(Token = "0x2000576")]
+	[AttributeUsage(AttributeTargets.Field)]
+	public sealed class FixedBufferAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.CompilerServices.FixedBufferAttribute" /> class.</summary>
+		/// <param name="elementType">The type of the elements contained in the buffer.</param>
+		/// <param name="length">The number of elements in the buffer.</param>
+		// Token: 0x06002C7D RID: 11389 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C7D")]
+		[Address(RVA = "0xE66140", Offset = "0xE65140", VA = "0x180E66140")]
+		public FixedBufferAttribute(Type elementType, int length)
+		{
+		}
+
+		/// <summary>Gets the type of the elements contained in the fixed buffer.</summary>
+		/// <returns>The type of the elements.</returns>
+		// Token: 0x170006C2 RID: 1730
+		// (get) Token: 0x06002C7E RID: 11390 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x170006C2")]
+		public Type ElementType
+		{
+			[Token(Token = "0x6002C7E")]
+			[Address(RVA = "0x411530", Offset = "0x410530", VA = "0x180411530")]
+			get
+			{
+				return null;
+			}
+		}
+
+		/// <summary>Gets the number of elements in the fixed buffer.</summary>
+		/// <returns>The number of elements in the fixed buffer.</returns>
+		// Token: 0x170006C3 RID: 1731
+		// (get) Token: 0x06002C7F RID: 11391 RVA: 0x00018CD8 File Offset: 0x00016ED8
+		[Token(Token = "0x170006C3")]
+		public int Length
+		{
+			[Token(Token = "0x6002C7F")]
+			[Address(RVA = "0x411540", Offset = "0x410540", VA = "0x180411540")]
+			get
+			{
+				return 0;
+			}
+		}
+
+		// Token: 0x0400195D RID: 6493
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x400195D")]
+		private Type elementType;
+
+		// Token: 0x0400195E RID: 6494
+		[FieldOffset(Offset = "0x18")]
+		[Token(Token = "0x400195E")]
+		private int length;
+	}
+}

mscorlib/System/Runtime/CompilerServices/FriendAccessAllowedAttribute.cs

@@ -0,0 +1,19 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	// Token: 0x02000578 RID: 1400
+	[Token(Token = "0x2000578")]
+	[FriendAccessAllowed]
+	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface)]
+	internal sealed class FriendAccessAllowedAttribute : Attribute
+	{
+		// Token: 0x06002C84 RID: 11396 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C84")]
+		[Address(RVA = "0x42BA20", Offset = "0x42AA20", VA = "0x18042BA20")]
+		public FriendAccessAllowedAttribute()
+		{
+		}
+	}
+}

mscorlib/System/Runtime/CompilerServices/IAsyncStateMachine.cs

@@ -0,0 +1,24 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Represents state machines that are generated for asynchronous methods. This type is intended for compiler use only.</summary>
+	// Token: 0x0200055C RID: 1372
+	[Token(Token = "0x200055C")]
+	public interface IAsyncStateMachine
+	{
+		/// <summary>Moves the state machine to its next state.</summary>
+		// Token: 0x06002C3D RID: 11325
+		[Token(Token = "0x6002C3D")]
+		[Address(Slot = "0")]
+		void MoveNext();
+
+		/// <summary>Configures the state machine with a heap-allocated replica.</summary>
+		/// <param name="stateMachine">The heap-allocated replica.</param>
+		// Token: 0x06002C3E RID: 11326
+		[Token(Token = "0x6002C3E")]
+		[Address(Slot = "1")]
+		void SetStateMachine(IAsyncStateMachine stateMachine);
+	}
+}

mscorlib/System/Runtime/CompilerServices/ICriticalNotifyCompletion.cs

@@ -0,0 +1,19 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Represents an awaiter that schedules continuations when an await operation completes.</summary>
+	// Token: 0x0200055E RID: 1374
+	[Token(Token = "0x200055E")]
+	public interface ICriticalNotifyCompletion : INotifyCompletion
+	{
+		/// <summary>Schedules the continuation action that's invoked when the instance completes.</summary>
+		/// <param name="continuation">The action to invoke when the operation completes.</param>
+		/// <exception cref="T:System.ArgumentNullException">The <paramref name="continuation" /> argument is null (Nothing in Visual Basic).</exception>
+		// Token: 0x06002C40 RID: 11328
+		[Token(Token = "0x6002C40")]
+		[Address(Slot = "0")]
+		void UnsafeOnCompleted(Action continuation);
+	}
+}

mscorlib/System/Runtime/CompilerServices/INotifyCompletion.cs

@@ -0,0 +1,19 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Represents an operation that schedules continuations when it completes.</summary>
+	// Token: 0x0200055D RID: 1373
+	[Token(Token = "0x200055D")]
+	public interface INotifyCompletion
+	{
+		/// <summary>Schedules the continuation action that's invoked when the instance completes.</summary>
+		/// <param name="continuation">The action to invoke when the operation completes.</param>
+		/// <exception cref="T:System.ArgumentNullException">The <paramref name="continuation" /> argument is null (Nothing in Visual Basic).</exception>
+		// Token: 0x06002C3F RID: 11327
+		[Token(Token = "0x6002C3F")]
+		[Address(Slot = "0")]
+		void OnCompleted(Action continuation);
+	}
+}

mscorlib/System/Runtime/CompilerServices/InternalsVisibleToAttribute.cs

@@ -0,0 +1,67 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Specifies that types that are ordinarily visible only within the current assembly are visible to a specified assembly.</summary>
+	// Token: 0x02000577 RID: 1399
+	[Token(Token = "0x2000577")]
+	[AttributeUsage(AttributeTargets.Assembly)]
+	public sealed class InternalsVisibleToAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.CompilerServices.InternalsVisibleToAttribute" /> class with the name of the specified friend assembly.</summary>
+		/// <param name="assemblyName">The name of a friend assembly.</param>
+		// Token: 0x06002C80 RID: 11392 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C80")]
+		[Address(RVA = "0x2CEEAB0", Offset = "0x2CEDAB0", VA = "0x182CEEAB0")]
+		public InternalsVisibleToAttribute(string assemblyName)
+		{
+		}
+
+		/// <summary>Gets the name of the friend assembly to which all types and type members that are marked with the <see langword="internal" /> keyword are to be made visible.</summary>
+		/// <returns>A string that represents the name of the friend assembly.</returns>
+		// Token: 0x170006C4 RID: 1732
+		// (get) Token: 0x06002C81 RID: 11393 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x170006C4")]
+		public string AssemblyName
+		{
+			[Token(Token = "0x6002C81")]
+			[Address(RVA = "0x411530", Offset = "0x410530", VA = "0x180411530")]
+			get
+			{
+				return null;
+			}
+		}
+
+		/// <summary>This property is not implemented.</summary>
+		/// <returns>This property does not return a value.</returns>
+		// Token: 0x170006C5 RID: 1733
+		// (get) Token: 0x06002C82 RID: 11394 RVA: 0x00018CF0 File Offset: 0x00016EF0
+		// (set) Token: 0x06002C83 RID: 11395 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x170006C5")]
+		public bool AllInternalsVisible
+		{
+			[Token(Token = "0x6002C82")]
+			[Address(RVA = "0x497570", Offset = "0x496570", VA = "0x180497570")]
+			get
+			{
+				return default(bool);
+			}
+			[Token(Token = "0x6002C83")]
+			[Address(RVA = "0x611070", Offset = "0x610070", VA = "0x180611070")]
+			set
+			{
+			}
+		}
+
+		// Token: 0x0400195F RID: 6495
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x400195F")]
+		private string _assemblyName;
+
+		// Token: 0x04001960 RID: 6496
+		[FieldOffset(Offset = "0x18")]
+		[Token(Token = "0x4001960")]
+		private bool _allInternalsVisible;
+	}
+}

mscorlib/System/Runtime/CompilerServices/IsByRefLikeAttribute.cs

@@ -0,0 +1,20 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Indicates that a structure is byref-like.</summary>
+	// Token: 0x0200054C RID: 1356
+	[Token(Token = "0x200054C")]
+	[AttributeUsage(AttributeTargets.Struct)]
+	public sealed class IsByRefLikeAttribute : Attribute
+	{
+		/// <summary>Creates a new instance of the <see cref="T:System.Runtime.CompilerServices.IsByRefLikeAttribute" /> class.</summary>
+		// Token: 0x06002C05 RID: 11269 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C05")]
+		[Address(RVA = "0x42BA20", Offset = "0x42AA20", VA = "0x18042BA20")]
+		public IsByRefLikeAttribute()
+		{
+		}
+	}
+}

mscorlib/System/Runtime/CompilerServices/IsReadOnlyAttribute.cs

@@ -0,0 +1,20 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Marks a program element as read-only.</summary>
+	// Token: 0x0200054D RID: 1357
+	[Token(Token = "0x200054D")]
+	[AttributeUsage(AttributeTargets.All)]
+	public sealed class IsReadOnlyAttribute : Attribute
+	{
+		/// <summary>Creates a new instance of the <see cref="T:System.Runtime.CompilerServices.IsReadOnlyAttribute" /> class.</summary>
+		// Token: 0x06002C06 RID: 11270 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C06")]
+		[Address(RVA = "0x42BA20", Offset = "0x42AA20", VA = "0x18042BA20")]
+		public IsReadOnlyAttribute()
+		{
+		}
+	}
+}

mscorlib/System/Runtime/CompilerServices/IsVolatile.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Runtime.InteropServices;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Marks a field as volatile. This class cannot be inherited.</summary>
+	// Token: 0x02000579 RID: 1401
+	[Token(Token = "0x2000579")]
+	[ComVisible(true)]
+	public static class IsVolatile
+	{
+	}
+}

mscorlib/System/Runtime/CompilerServices/IteratorStateMachineAttribute.cs

@@ -0,0 +1,22 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Indicates whether a method in Visual Basic is marked with the <see langword="Iterator" /> modifier.</summary>
+	// Token: 0x0200055F RID: 1375
+	[Token(Token = "0x200055F")]
+	[AttributeUsage(AttributeTargets.Method)]
+	[Serializable]
+	public sealed class IteratorStateMachineAttribute : StateMachineAttribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.CompilerServices.IteratorStateMachineAttribute" /> class.</summary>
+		/// <param name="stateMachineType">The type object for the underlying state machine type that's used to implement a state machine method.</param>
+		// Token: 0x06002C41 RID: 11329 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C41")]
+		[Address(RVA = "0x681CA0", Offset = "0x680CA0", VA = "0x180681CA0")]
+		public IteratorStateMachineAttribute(Type stateMachineType)
+		{
+		}
+	}
+}

mscorlib/System/Runtime/CompilerServices/JitHelpers.cs

@@ -0,0 +1,34 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	// Token: 0x0200057E RID: 1406
+	[Token(Token = "0x200057E")]
+	[FriendAccessAllowed]
+	internal static class JitHelpers
+	{
+		// Token: 0x06002C89 RID: 11401 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002C89")]
+		[Address(RVA = "0x1E590E0", Offset = "0x1E580E0", VA = "0x181E590E0")]
+		internal static T UnsafeCast<T>(object o) where T : class
+		{
+			return null;
+		}
+
+		// Token: 0x06002C8A RID: 11402 RVA: 0x00018D08 File Offset: 0x00016F08
+		[Token(Token = "0x6002C8A")]
+		[Address(RVA = "0x1E590E0", Offset = "0x1E580E0", VA = "0x181E590E0")]
+		internal static int UnsafeEnumCast<T>(T val) where T : struct
+		{
+			return 0;
+		}
+
+		// Token: 0x06002C8B RID: 11403 RVA: 0x00018D20 File Offset: 0x00016F20
+		[Token(Token = "0x6002C8B")]
+		internal static long UnsafeEnumCastLong<T>(T val) where T : struct
+		{
+			return 0L;
+		}
+	}
+}

mscorlib/System/Runtime/CompilerServices/LoadHint.cs

@@ -0,0 +1,25 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Specifies the preferred default binding for a dependent assembly.</summary>
+	// Token: 0x0200056C RID: 1388
+	[Token(Token = "0x200056C")]
+	[Serializable]
+	public enum LoadHint
+	{
+		/// <summary>No preference specified.</summary>
+		// Token: 0x04001952 RID: 6482
+		[Token(Token = "0x4001952")]
+		Default,
+		/// <summary>The dependency is always loaded.</summary>
+		// Token: 0x04001953 RID: 6483
+		[Token(Token = "0x4001953")]
+		Always,
+		/// <summary>The dependency is sometimes loaded.</summary>
+		// Token: 0x04001954 RID: 6484
+		[Token(Token = "0x4001954")]
+		Sometimes
+	}
+}

mscorlib/System/Runtime/CompilerServices/RuntimeCompatibilityAttribute.cs

@@ -0,0 +1,41 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Specifies whether to wrap exceptions that do not derive from the <see cref="T:System.Exception" /> class with a <see cref="T:System.Runtime.CompilerServices.RuntimeWrappedException" /> object. This class cannot be inherited.</summary>
+	// Token: 0x02000560 RID: 1376
+	[Token(Token = "0x2000560")]
+	[AttributeUsage(AttributeTargets.Assembly)]
+	[Serializable]
+	public sealed class RuntimeCompatibilityAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.CompilerServices.RuntimeCompatibilityAttribute" /> class.</summary>
+		// Token: 0x06002C42 RID: 11330 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C42")]
+		[Address(RVA = "0x42BA20", Offset = "0x42AA20", VA = "0x18042BA20")]
+		public RuntimeCompatibilityAttribute()
+		{
+		}
+
+		/// <summary>Gets or sets a value that indicates whether to wrap exceptions that do not derive from the <see cref="T:System.Exception" /> class with a <see cref="T:System.Runtime.CompilerServices.RuntimeWrappedException" /> object.</summary>
+		/// <returns>
+		///   <see langword="true" /> if exceptions that do not derive from the <see cref="T:System.Exception" /> class should appear wrapped with a <see cref="T:System.Runtime.CompilerServices.RuntimeWrappedException" /> object; otherwise, <see langword="false" />.</returns>
+		// Token: 0x170006B5 RID: 1717
+		// (set) Token: 0x06002C43 RID: 11331 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x170006B5")]
+		public bool WrapNonExceptionThrows
+		{
+			[Token(Token = "0x6002C43")]
+			[Address(RVA = "0x62ADC0", Offset = "0x629DC0", VA = "0x18062ADC0")]
+			set
+			{
+			}
+		}
+
+		// Token: 0x04001943 RID: 6467
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x4001943")]
+		private bool m_wrapNonExceptionThrows;
+	}
+}

mscorlib/System/Runtime/CompilerServices/RuntimeHelpers.cs

@@ -0,0 +1,118 @@
+using System;
+using System.Runtime.ConstrainedExecution;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Provides a set of static methods and properties that provide support for compilers. This class cannot be inherited.</summary>
+	// Token: 0x02000582 RID: 1410
+	[Token(Token = "0x2000582")]
+	public static class RuntimeHelpers
+	{
+		// Token: 0x06002C99 RID: 11417 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C99")]
+		[Address(RVA = "0x2CFB360", Offset = "0x2CFA360", VA = "0x182CFB360")]
+		private static void InitializeArray(Array array, IntPtr fldHandle)
+		{
+		}
+
+		/// <summary>Provides a fast way to initialize an array from data that is stored in a module.</summary>
+		/// <param name="array">The array to be initialized.</param>
+		/// <param name="fldHandle">A field handle that specifies the location of the data used to initialize the array.</param>
+		// Token: 0x06002C9A RID: 11418 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C9A")]
+		[Address(RVA = "0x2CFB2E0", Offset = "0x2CFA2E0", VA = "0x182CFB2E0")]
+		public static void InitializeArray(Array array, RuntimeFieldHandle fldHandle)
+		{
+		}
+
+		/// <summary>Gets the offset, in bytes, to the data in the given string.</summary>
+		/// <returns>The byte offset, from the start of the <see cref="T:System.String" /> object to the first character in the string.</returns>
+		// Token: 0x170006C6 RID: 1734
+		// (get) Token: 0x06002C9B RID: 11419 RVA: 0x00018D68 File Offset: 0x00016F68
+		[Token(Token = "0x170006C6")]
+		public static int OffsetToStringData
+		{
+			[Token(Token = "0x6002C9B")]
+			[Address(RVA = "0x2CFB400", Offset = "0x2CFA400", VA = "0x182CFB400")]
+			get
+			{
+				return 0;
+			}
+		}
+
+		/// <summary>Serves as a hash function for a particular object, and is suitable for use in algorithms and data structures that use hash codes, such as a hash table.</summary>
+		/// <param name="o">An object to retrieve the hash code for.</param>
+		/// <returns>A hash code for the object identified by the <paramref name="o" /> parameter.</returns>
+		// Token: 0x06002C9C RID: 11420 RVA: 0x00018D80 File Offset: 0x00016F80
+		[Token(Token = "0x6002C9C")]
+		[Address(RVA = "0x4F9150", Offset = "0x4F8150", VA = "0x1804F9150")]
+		public static int GetHashCode(object o)
+		{
+			return 0;
+		}
+
+		/// <summary>Boxes a value type.</summary>
+		/// <param name="obj">The value type to be boxed.</param>
+		/// <returns>A boxed copy of <paramref name="obj" /> if it is a value class; otherwise, <paramref name="obj" /> itself.</returns>
+		// Token: 0x06002C9D RID: 11421 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002C9D")]
+		[Address(RVA = "0x2CFB2D0", Offset = "0x2CFA2D0", VA = "0x182CFB2D0")]
+		public static object GetObjectValue(object obj)
+		{
+			return null;
+		}
+
+		// Token: 0x06002C9E RID: 11422 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C9E")]
+		[Address(RVA = "0x2CFB3F0", Offset = "0x2CFA3F0", VA = "0x182CFB3F0")]
+		private static void RunClassConstructor(IntPtr type)
+		{
+		}
+
+		/// <summary>Runs a specified class constructor method.</summary>
+		/// <param name="type">A type handle that specifies the class constructor method to run.</param>
+		/// <exception cref="T:System.TypeInitializationException">The class initializer throws an exception.</exception>
+		// Token: 0x06002C9F RID: 11423 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C9F")]
+		[Address(RVA = "0x2CFB370", Offset = "0x2CFA370", VA = "0x182CFB370")]
+		public static void RunClassConstructor(RuntimeTypeHandle type)
+		{
+		}
+
+		// Token: 0x06002CA0 RID: 11424 RVA: 0x00018D98 File Offset: 0x00016F98
+		[Token(Token = "0x6002CA0")]
+		[Address(RVA = "0xAE5C70", Offset = "0xAE4C70", VA = "0x180AE5C70")]
+		private static bool SufficientExecutionStack()
+		{
+			return default(bool);
+		}
+
+		// Token: 0x06002CA1 RID: 11425 RVA: 0x00018DB0 File Offset: 0x00016FB0
+		[Token(Token = "0x6002CA1")]
+		[Address(RVA = "0xAE5C70", Offset = "0xAE4C70", VA = "0x180AE5C70")]
+		public static bool TryEnsureSufficientExecutionStack()
+		{
+			return default(bool);
+		}
+
+		/// <summary>Designates a body of code as a constrained execution region (CER).</summary>
+		// Token: 0x06002CA2 RID: 11426 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CA2")]
+		[Address(RVA = "0x4242D0", Offset = "0x4232D0", VA = "0x1804242D0")]
+		[MonoTODO]
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
+		[MonoTODO("Currently a no-op")]
+		public static void PrepareConstrainedRegions()
+		{
+		}
+
+		// Token: 0x06002CA3 RID: 11427 RVA: 0x00018DC8 File Offset: 0x00016FC8
+		[Token(Token = "0x6002CA3")]
+		[Address(RVA = "0x21B5930", Offset = "0x21B4930", VA = "0x1821B5930")]
+		public static bool IsReferenceOrContainsReferences<T>()
+		{
+			return default(bool);
+		}
+	}
+}

mscorlib/System/Runtime/CompilerServices/RuntimeWrappedException.cs

@@ -0,0 +1,65 @@
+using System;
+using System.Runtime.Serialization;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Wraps an exception that does not derive from the <see cref="T:System.Exception" /> class. This class cannot be inherited.</summary>
+	// Token: 0x02000561 RID: 1377
+	[Token(Token = "0x2000561")]
+	[Serializable]
+	public sealed class RuntimeWrappedException : Exception
+	{
+		// Token: 0x06002C44 RID: 11332 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C44")]
+		[Address(RVA = "0x2CFC540", Offset = "0x2CFB540", VA = "0x182CFC540")]
+		private RuntimeWrappedException(object thrownObject)
+		{
+		}
+
+		/// <summary>Gets the object that was wrapped by the <see cref="T:System.Runtime.CompilerServices.RuntimeWrappedException" /> object.</summary>
+		/// <returns>The object that was wrapped by the <see cref="T:System.Runtime.CompilerServices.RuntimeWrappedException" /> object.</returns>
+		// Token: 0x170006B6 RID: 1718
+		// (get) Token: 0x06002C45 RID: 11333 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x170006B6")]
+		public object WrappedException
+		{
+			[Token(Token = "0x6002C45")]
+			[Address(RVA = "0x4C31C0", Offset = "0x4C21C0", VA = "0x1804C31C0")]
+			get
+			{
+				return null;
+			}
+		}
+
+		/// <summary>Sets the <see cref="T:System.Runtime.Serialization.SerializationInfo" /> object with information about the exception.</summary>
+		/// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo" /> object that holds the serialized object data about the exception being thrown.</param>
+		/// <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext" /> object that contains contextual information about the source or destination.</param>
+		/// <exception cref="T:System.ArgumentNullException">The <paramref name="info" /> parameter is <see langword="null" />.</exception>
+		// Token: 0x06002C46 RID: 11334 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C46")]
+		[Address(RVA = "0x2CFC450", Offset = "0x2CFB450", VA = "0x182CFC450", Slot = "10")]
+		public override void GetObjectData(SerializationInfo info, StreamingContext context)
+		{
+		}
+
+		// Token: 0x06002C47 RID: 11335 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C47")]
+		[Address(RVA = "0x2CFC610", Offset = "0x2CFB610", VA = "0x182CFC610")]
+		internal RuntimeWrappedException(SerializationInfo info, StreamingContext context)
+		{
+		}
+
+		// Token: 0x06002C48 RID: 11336 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C48")]
+		[Address(RVA = "0x2CFC5E0", Offset = "0x2CFB5E0", VA = "0x182CFC5E0")]
+		internal RuntimeWrappedException()
+		{
+		}
+
+		// Token: 0x04001944 RID: 6468
+		[FieldOffset(Offset = "0x88")]
+		[Token(Token = "0x4001944")]
+		private object m_wrappedException;
+	}
+}

mscorlib/System/Runtime/CompilerServices/StateMachineAttribute.cs

@@ -0,0 +1,37 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Allows you to determine whether a method is a state machine method.</summary>
+	// Token: 0x02000562 RID: 1378
+	[Token(Token = "0x2000562")]
+	[AttributeUsage(AttributeTargets.Method)]
+	[Serializable]
+	public class StateMachineAttribute : Attribute
+	{
+		/// <summary>Returns the type object for the underlying state machine type that was generated by the compiler to implement the state machine method.</summary>
+		/// <returns>Gets the type object for the underlying state machine type that was generated by the compiler to implement the state machine method.</returns>
+		// Token: 0x170006B7 RID: 1719
+		// (set) Token: 0x06002C49 RID: 11337 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x170006B7")]
+		private Type StateMachineType
+		{
+			[Token(Token = "0x6002C49")]
+			[Address(RVA = "0x415800", Offset = "0x414800", VA = "0x180415800")]
+			[CompilerGenerated]
+			set
+			{
+			}
+		}
+
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.CompilerServices.StateMachineAttribute" /> class.</summary>
+		/// <param name="stateMachineType">The type object for the underlying state machine type that was generated by the compiler to implement the state machine method.</param>
+		// Token: 0x06002C4A RID: 11338 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C4A")]
+		[Address(RVA = "0x681CA0", Offset = "0x680CA0", VA = "0x180681CA0")]
+		public StateMachineAttribute(Type stateMachineType)
+		{
+		}
+	}
+}

mscorlib/System/Runtime/CompilerServices/StringFreezingAttribute.cs

@@ -0,0 +1,21 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Deprecated. Freezes a string literal when creating native images using the Ngen.exe (Native Image Generator). This class cannot be inherited.</summary>
+	// Token: 0x0200057D RID: 1405
+	[Token(Token = "0x200057D")]
+	[AttributeUsage(AttributeTargets.Assembly)]
+	[Serializable]
+	public sealed class StringFreezingAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.CompilerServices.StringFreezingAttribute" /> class.</summary>
+		// Token: 0x06002C88 RID: 11400 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C88")]
+		[Address(RVA = "0x42BA20", Offset = "0x42AA20", VA = "0x18042BA20")]
+		public StringFreezingAttribute()
+		{
+		}
+	}
+}

mscorlib/System/Runtime/CompilerServices/SuppressIldasmAttribute.cs

@@ -0,0 +1,20 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Prevents the Ildasm.exe (IL Disassembler) from disassembling an assembly. This class cannot be inherited.</summary>
+	// Token: 0x0200057A RID: 1402
+	[Token(Token = "0x200057A")]
+	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module)]
+	public sealed class SuppressIldasmAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.CompilerServices.SuppressIldasmAttribute" /> class.</summary>
+		// Token: 0x06002C85 RID: 11397 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C85")]
+		[Address(RVA = "0x42BA20", Offset = "0x42AA20", VA = "0x18042BA20")]
+		public SuppressIldasmAttribute()
+		{
+		}
+	}
+}

mscorlib/System/Runtime/CompilerServices/TaskAwaiter.2.cs

@@ -0,0 +1,79 @@
+using System;
+using System.Threading.Tasks;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Represents an object that waits for the completion of an asynchronous task and provides a parameter for the result.</summary>
+	/// <typeparam name="TResult">The result for the task.</typeparam>
+	// Token: 0x02000564 RID: 1380
+	[Token(Token = "0x2000564")]
+	public struct TaskAwaiter<TResult> : ICriticalNotifyCompletion, INotifyCompletion
+	{
+		// Token: 0x06002C54 RID: 11348 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C54")]
+		[Address(RVA = "0x593200", Offset = "0x592200", VA = "0x180593200")]
+		internal TaskAwaiter(Task<TResult> task)
+		{
+		}
+
+		/// <summary>Gets a value that indicates whether the asynchronous task has completed.</summary>
+		/// <returns>
+		///   <see langword="true" /> if the task has completed; otherwise, <see langword="false" />.</returns>
+		/// <exception cref="T:System.NullReferenceException">The <see cref="T:System.Runtime.CompilerServices.TaskAwaiter`1" /> object was not properly initialized.</exception>
+		// Token: 0x170006B9 RID: 1721
+		// (get) Token: 0x06002C55 RID: 11349 RVA: 0x00018C00 File Offset: 0x00016E00
+		[Token(Token = "0x170006B9")]
+		public bool IsCompleted
+		{
+			[Token(Token = "0x6002C55")]
+			[Address(RVA = "0x2CEC370", Offset = "0x2CEB370", VA = "0x182CEC370")]
+			get
+			{
+				return default(bool);
+			}
+		}
+
+		/// <summary>Sets the action to perform when the <see cref="T:System.Runtime.CompilerServices.TaskAwaiter`1" /> object stops waiting for the asynchronous task to complete.</summary>
+		/// <param name="continuation">The action to perform when the wait operation completes.</param>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="continuation" /> is <see langword="null" />.</exception>
+		/// <exception cref="T:System.NullReferenceException">The <see cref="T:System.Runtime.CompilerServices.TaskAwaiter`1" /> object was not properly initialized.</exception>
+		// Token: 0x06002C56 RID: 11350 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C56")]
+		[Address(RVA = "0x2CFD110", Offset = "0x2CFC110", VA = "0x182CFD110", Slot = "5")]
+		public void OnCompleted(Action continuation)
+		{
+		}
+
+		/// <summary>Schedules the continuation action for the asynchronous task associated with this awaiter.</summary>
+		/// <param name="continuation">The action to invoke when the await operation completes.</param>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="continuation" /> is <see langword="null" />.</exception>
+		/// <exception cref="T:System.InvalidOperationException">The awaiter was not properly initialized.</exception>
+		// Token: 0x06002C57 RID: 11351 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C57")]
+		[Address(RVA = "0x2CFD270", Offset = "0x2CFC270", VA = "0x182CFD270", Slot = "4")]
+		public void UnsafeOnCompleted(Action continuation)
+		{
+		}
+
+		/// <summary>Ends the wait for the completion of the asynchronous task.</summary>
+		/// <returns>The result of the completed task.</returns>
+		/// <exception cref="T:System.NullReferenceException">The <see cref="T:System.Runtime.CompilerServices.TaskAwaiter`1" /> object was not properly initialized.</exception>
+		/// <exception cref="T:System.Threading.Tasks.TaskCanceledException">The task was canceled.</exception>
+		/// <exception cref="T:System.Exception">The task completed in a <see cref="F:System.Threading.Tasks.TaskStatus.Faulted" /> state.</exception>
+		// Token: 0x06002C58 RID: 11352 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002C58")]
+		[Address(RVA = "0x2F02CE0", Offset = "0x2F01CE0", VA = "0x182F02CE0")]
+		public TResult GetResult()
+		{
+			return null;
+		}
+
+		// Token: 0x04001947 RID: 6471
+		[FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x4001947")]
+		private readonly Task<TResult> m_task;
+	}
+}

mscorlib/System/Runtime/CompilerServices/TaskAwaiter.cs

@@ -0,0 +1,104 @@
+using System;
+using System.Threading.Tasks;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Provides an object that waits for the completion of an asynchronous task.</summary>
+	// Token: 0x02000563 RID: 1379
+	[Token(Token = "0x2000563")]
+	public struct TaskAwaiter : ICriticalNotifyCompletion, INotifyCompletion
+	{
+		// Token: 0x06002C4B RID: 11339 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C4B")]
+		[Address(RVA = "0x593200", Offset = "0x592200", VA = "0x180593200")]
+		internal TaskAwaiter(Task task)
+		{
+		}
+
+		/// <summary>Gets a value that indicates whether the asynchronous task has completed.</summary>
+		/// <returns>
+		///   <see langword="true" /> if the task has completed; otherwise, <see langword="false" />.</returns>
+		/// <exception cref="T:System.NullReferenceException">The <see cref="T:System.Runtime.CompilerServices.TaskAwaiter" /> object was not properly initialized.</exception>
+		// Token: 0x170006B8 RID: 1720
+		// (get) Token: 0x06002C4C RID: 11340 RVA: 0x00018BE8 File Offset: 0x00016DE8
+		[Token(Token = "0x170006B8")]
+		public bool IsCompleted
+		{
+			[Token(Token = "0x6002C4C")]
+			[Address(RVA = "0x2CEC370", Offset = "0x2CEB370", VA = "0x182CEC370")]
+			get
+			{
+				return default(bool);
+			}
+		}
+
+		/// <summary>Sets the action to perform when the <see cref="T:System.Runtime.CompilerServices.TaskAwaiter" /> object stops waiting for the asynchronous task to complete.</summary>
+		/// <param name="continuation">The action to perform when the wait operation completes.</param>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="continuation" /> is <see langword="null" />.</exception>
+		/// <exception cref="T:System.NullReferenceException">The <see cref="T:System.Runtime.CompilerServices.TaskAwaiter" /> object was not properly initialized.</exception>
+		// Token: 0x06002C4D RID: 11341 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C4D")]
+		[Address(RVA = "0x2CFD110", Offset = "0x2CFC110", VA = "0x182CFD110", Slot = "5")]
+		public void OnCompleted(Action continuation)
+		{
+		}
+
+		/// <summary>Schedules the continuation action for the asynchronous task that is associated with this awaiter.</summary>
+		/// <param name="continuation">The action to invoke when the await operation completes.</param>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="continuation" /> is <see langword="null" />.</exception>
+		/// <exception cref="T:System.InvalidOperationException">The awaiter was not properly initialized.</exception>
+		// Token: 0x06002C4E RID: 11342 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C4E")]
+		[Address(RVA = "0x2CFD270", Offset = "0x2CFC270", VA = "0x182CFD270", Slot = "4")]
+		public void UnsafeOnCompleted(Action continuation)
+		{
+		}
+
+		/// <summary>Ends the wait for the completion of the asynchronous task.</summary>
+		/// <exception cref="T:System.NullReferenceException">The <see cref="T:System.Runtime.CompilerServices.TaskAwaiter" /> object was not properly initialized.</exception>
+		/// <exception cref="T:System.Threading.Tasks.TaskCanceledException">The task was canceled.</exception>
+		/// <exception cref="T:System.Exception">The task completed in a <see cref="F:System.Threading.Tasks.TaskStatus.Faulted" /> state.</exception>
+		// Token: 0x06002C4F RID: 11343 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C4F")]
+		[Address(RVA = "0x2CEC300", Offset = "0x2CEB300", VA = "0x182CEC300")]
+		public void GetResult()
+		{
+		}
+
+		// Token: 0x06002C50 RID: 11344 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C50")]
+		[Address(RVA = "0x2CFD290", Offset = "0x2CFC290", VA = "0x182CFD290")]
+		internal static void ValidateEnd(Task task)
+		{
+		}
+
+		// Token: 0x06002C51 RID: 11345 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C51")]
+		[Address(RVA = "0x2CFCEE0", Offset = "0x2CFBEE0", VA = "0x182CFCEE0")]
+		private static void HandleNonSuccessAndDebuggerNotification(Task task)
+		{
+		}
+
+		// Token: 0x06002C52 RID: 11346 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C52")]
+		[Address(RVA = "0x2CFD140", Offset = "0x2CFC140", VA = "0x182CFD140")]
+		private static void ThrowForNonSuccess(Task task)
+		{
+		}
+
+		// Token: 0x06002C53 RID: 11347 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C53")]
+		[Address(RVA = "0x2CFD040", Offset = "0x2CFC040", VA = "0x182CFD040")]
+		internal static void OnCompletedInternal(Task task, Action continuation, bool continueOnCapturedContext, bool flowExecutionContext)
+		{
+		}
+
+		// Token: 0x04001946 RID: 6470
+		[FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x4001946")]
+		private readonly Task m_task;
+	}
+}

mscorlib/System/Runtime/CompilerServices/TupleElementNamesAttribute.cs

@@ -0,0 +1,27 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Indicates that the use of a value tuple on a member is meant to be treated as a tuple with element names.</summary>
+	// Token: 0x0200054E RID: 1358
+	[Token(Token = "0x200054E")]
+	[CLSCompliant(false)]
+	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue)]
+	public sealed class TupleElementNamesAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.CompilerServices.TupleElementNamesAttribute" /> class.</summary>
+		/// <param name="transformNames">A string array that specifies, in a pre-order depth-first traversal of a type's construction, which value tuple occurrences are meant to carry element names.</param>
+		// Token: 0x06002C07 RID: 11271 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C07")]
+		[Address(RVA = "0x2CFD410", Offset = "0x2CFC410", VA = "0x182CFD410")]
+		public TupleElementNamesAttribute(string[] transformNames)
+		{
+		}
+
+		// Token: 0x0400192A RID: 6442
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x400192A")]
+		private readonly string[] _transformNames;
+	}
+}

mscorlib/System/Runtime/CompilerServices/TypeDependencyAttribute.cs

@@ -0,0 +1,23 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	// Token: 0x0200057B RID: 1403
+	[Token(Token = "0x200057B")]
+	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface)]
+	internal sealed class TypeDependencyAttribute : Attribute
+	{
+		// Token: 0x06002C86 RID: 11398 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C86")]
+		[Address(RVA = "0x2CFD490", Offset = "0x2CFC490", VA = "0x182CFD490")]
+		public TypeDependencyAttribute(string typeName)
+		{
+		}
+
+		// Token: 0x04001961 RID: 6497
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x4001961")]
+		private string typeName;
+	}
+}

mscorlib/System/Runtime/CompilerServices/TypeForwardedFromAttribute.cs

@@ -0,0 +1,43 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Specifies a source <see cref="T:System.Type" /> in another assembly.</summary>
+	// Token: 0x02000569 RID: 1385
+	[Token(Token = "0x2000569")]
+	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Interface | AttributeTargets.Delegate)]
+	public sealed class TypeForwardedFromAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.CompilerServices.TypeForwardedFromAttribute" /> class.</summary>
+		/// <param name="assemblyFullName">The source <see cref="T:System.Type" /> in another assembly.</param>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="assemblyFullName" /> is <see langword="null" /> or empty.</exception>
+		// Token: 0x06002C67 RID: 11367 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C67")]
+		[Address(RVA = "0x2CFD510", Offset = "0x2CFC510", VA = "0x182CFD510")]
+		public TypeForwardedFromAttribute(string assemblyFullName)
+		{
+		}
+
+		/// <summary>Gets the assembly-qualified name of the source type.</summary>
+		/// <returns>The assembly-qualified name of the source type.</returns>
+		// Token: 0x170006BC RID: 1724
+		// (get) Token: 0x06002C68 RID: 11368 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x170006BC")]
+		public string AssemblyFullName
+		{
+			[Token(Token = "0x6002C68")]
+			[Address(RVA = "0x411530", Offset = "0x410530", VA = "0x180411530")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x0400194E RID: 6478
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x400194E")]
+		private string assemblyFullName;
+	}
+}

mscorlib/System/Runtime/CompilerServices/Unsafe.cs

@@ -0,0 +1,50 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	// Token: 0x02000583 RID: 1411
+	[Token(Token = "0x2000583")]
+	internal static class Unsafe
+	{
+		// Token: 0x06002CA4 RID: 11428 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002CA4")]
+		[Address(RVA = "0x1E63960", Offset = "0x1E62960", VA = "0x181E63960")]
+		public static T Add<T>(ref T source, int elementOffset)
+		{
+			return null;
+		}
+
+		// Token: 0x06002CA5 RID: 11429 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002CA5")]
+		[Address(RVA = "0x1E63950", Offset = "0x1E62950", VA = "0x181E63950")]
+		public static T AddByteOffset<T>(ref T source, IntPtr byteOffset)
+		{
+			return null;
+		}
+
+		// Token: 0x06002CA6 RID: 11430 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002CA6")]
+		[Address(RVA = "0x4A65C0", Offset = "0x4A55C0", VA = "0x1804A65C0")]
+		public static T As<T>(object o) where T : class
+		{
+			return null;
+		}
+
+		// Token: 0x06002CA7 RID: 11431 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002CA7")]
+		[Address(RVA = "0x4A65C0", Offset = "0x4A55C0", VA = "0x1804A65C0")]
+		public unsafe static T AsRef<T>(void* source)
+		{
+			return null;
+		}
+
+		// Token: 0x06002CA8 RID: 11432 RVA: 0x00018DE0 File Offset: 0x00016FE0
+		[Token(Token = "0x6002CA8")]
+		[Address(RVA = "0x27D8DD0", Offset = "0x27D7DD0", VA = "0x1827D8DD0")]
+		public static IntPtr ByteOffset<T>(ref T origin, ref T target)
+		{
+			return 0;
+		}
+	}
+}

mscorlib/System/Runtime/CompilerServices/UnsafeValueTypeAttribute.cs

@@ -0,0 +1,21 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Specifies that a type contains an unmanaged array that might potentially overflow. This class cannot be inherited.</summary>
+	// Token: 0x0200057C RID: 1404
+	[Token(Token = "0x200057C")]
+	[AttributeUsage(AttributeTargets.Struct)]
+	[Serializable]
+	public sealed class UnsafeValueTypeAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.CompilerServices.UnsafeValueTypeAttribute" /> class.</summary>
+		// Token: 0x06002C87 RID: 11399 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C87")]
+		[Address(RVA = "0x42BA20", Offset = "0x42AA20", VA = "0x18042BA20")]
+		public UnsafeValueTypeAttribute()
+		{
+		}
+	}
+}

mscorlib/System/Runtime/CompilerServices/YieldAwaitable.cs

@@ -0,0 +1,94 @@
+using System;
+using System.Threading;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Provides the context for waiting when asynchronously switching into a target environment.</summary>
+	// Token: 0x0200056A RID: 1386
+	[Token(Token = "0x200056A")]
+	public struct YieldAwaitable
+	{
+		/// <summary>Retrieves a <see cref="T:System.Runtime.CompilerServices.YieldAwaitable.YieldAwaiter" /> object  for this instance of the class.</summary>
+		/// <returns>The object that is used to monitor the completion of an asynchronous operation.</returns>
+		// Token: 0x06002C69 RID: 11369 RVA: 0x00018C78 File Offset: 0x00016E78
+		[Token(Token = "0x6002C69")]
+		[Address(RVA = "0x424690", Offset = "0x423690", VA = "0x180424690")]
+		public YieldAwaitable.YieldAwaiter GetAwaiter()
+		{
+			return default(YieldAwaitable.YieldAwaiter);
+		}
+
+		/// <summary>Provides an awaiter for switching into a target environment.</summary>
+		// Token: 0x0200056B RID: 1387
+		[Token(Token = "0x200056B")]
+		public struct YieldAwaiter : ICriticalNotifyCompletion, INotifyCompletion
+		{
+			/// <summary>Gets a value that indicates whether a yield is not required.</summary>
+			/// <returns>Always <see langword="false" />, which indicates that a yield is always required for <see cref="T:System.Runtime.CompilerServices.YieldAwaitable.YieldAwaiter" />.</returns>
+			// Token: 0x170006BD RID: 1725
+			// (get) Token: 0x06002C6A RID: 11370 RVA: 0x00018C90 File Offset: 0x00016E90
+			[Token(Token = "0x170006BD")]
+			public bool IsCompleted
+			{
+				[Token(Token = "0x6002C6A")]
+				[Address(RVA = "0x424690", Offset = "0x423690", VA = "0x180424690")]
+				get
+				{
+					return default(bool);
+				}
+			}
+
+			/// <summary>Sets the continuation to invoke.</summary>
+			/// <param name="continuation">The action to invoke asynchronously.</param>
+			/// <exception cref="T:System.ArgumentNullException">
+			///   <paramref name="continuation" /> is <see langword="null" />.</exception>
+			// Token: 0x06002C6B RID: 11371 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6002C6B")]
+			[Address(RVA = "0x2CFD990", Offset = "0x2CFC990", VA = "0x182CFD990", Slot = "5")]
+			public void OnCompleted(Action continuation)
+			{
+			}
+
+			/// <summary>Posts the <paramref name="continuation" /> back to the current context.</summary>
+			/// <param name="continuation">The action to invoke asynchronously.</param>
+			/// <exception cref="T:System.ArgumentNullException">The <paramref name="continuation" /> argument is <see langword="null" />.</exception>
+			// Token: 0x06002C6C RID: 11372 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6002C6C")]
+			[Address(RVA = "0x2CFDD30", Offset = "0x2CFCD30", VA = "0x182CFDD30", Slot = "4")]
+			public void UnsafeOnCompleted(Action continuation)
+			{
+			}
+
+			// Token: 0x06002C6D RID: 11373 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6002C6D")]
+			[Address(RVA = "0x2CFD9F0", Offset = "0x2CFC9F0", VA = "0x182CFD9F0")]
+			private static void QueueContinuation(Action continuation, bool flowContext)
+			{
+			}
+
+			// Token: 0x06002C6E RID: 11374 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6002C6E")]
+			[Address(RVA = "0x2CFDCD0", Offset = "0x2CFCCD0", VA = "0x182CFDCD0")]
+			private static void RunAction(object state)
+			{
+			}
+
+			/// <summary>Ends the await operation.</summary>
+			// Token: 0x06002C6F RID: 11375 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6002C6F")]
+			[Address(RVA = "0x4242D0", Offset = "0x4232D0", VA = "0x1804242D0")]
+			public void GetResult()
+			{
+			}
+
+			// Token: 0x0400194F RID: 6479
+			[Token(Token = "0x400194F")]
+			private static readonly WaitCallback s_waitCallbackRunAction;
+
+			// Token: 0x04001950 RID: 6480
+			[Token(Token = "0x4001950")]
+			private static readonly SendOrPostCallback s_sendOrPostCallbackRunAction;
+		}
+	}
+}

mscorlib/System/Runtime/ConstrainedExecution/Cer.cs

@@ -0,0 +1,25 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.ConstrainedExecution
+{
+	/// <summary>Specifies a method's behavior when called within a constrained execution region.</summary>
+	// Token: 0x0200054A RID: 1354
+	[Token(Token = "0x200054A")]
+	[Serializable]
+	public enum Cer
+	{
+		/// <summary>The method, type, or assembly has no concept of a CER. It does not take advantage of CER guarantees. This implies the following:</summary>
+		// Token: 0x04001925 RID: 6437
+		[Token(Token = "0x4001925")]
+		None,
+		/// <summary>In the face of exceptional conditions, the method might fail. In this case, the method will report back to the calling method whether it succeeded or failed. The method must have a CER around the method body to ensure that it can report the return value.</summary>
+		// Token: 0x04001926 RID: 6438
+		[Token(Token = "0x4001926")]
+		MayFail,
+		/// <summary>In the face of exceptional conditions, the method is guaranteed to succeed. You should always construct a CER around the method that is called, even when it is called from within a non-CER region. A method is successful if it accomplishes what is intended. For example, marking <see cref="P:System.Collections.ArrayList.Count" /> with ReliabilityContractAttribute(Cer.Success) implies that when it is run under a CER, it always returns a count of the number of elements in the <see cref="T:System.Collections.ArrayList" /> and it can never leave the internal fields in an undetermined state.</summary>
+		// Token: 0x04001927 RID: 6439
+		[Token(Token = "0x4001927")]
+		Success
+	}
+}

mscorlib/System/Runtime/ConstrainedExecution/Consistency.cs

@@ -0,0 +1,29 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.ConstrainedExecution
+{
+	/// <summary>Specifies a reliability contract.</summary>
+	// Token: 0x02000549 RID: 1353
+	[Token(Token = "0x2000549")]
+	[Serializable]
+	public enum Consistency
+	{
+		/// <summary>In the face of exceptional conditions, the CLR makes no guarantees regarding state consistency; that is, the condition might corrupt the process.</summary>
+		// Token: 0x04001920 RID: 6432
+		[Token(Token = "0x4001920")]
+		MayCorruptProcess,
+		/// <summary>In the face of exceptional conditions, the common language runtime (CLR) makes no guarantees regarding state consistency in the current application domain.</summary>
+		// Token: 0x04001921 RID: 6433
+		[Token(Token = "0x4001921")]
+		MayCorruptAppDomain,
+		/// <summary>In the face of exceptional conditions, the method is guaranteed to limit state corruption to the current instance.</summary>
+		// Token: 0x04001922 RID: 6434
+		[Token(Token = "0x4001922")]
+		MayCorruptInstance,
+		/// <summary>In the face of exceptional conditions, the method is guaranteed not to corrupt state.</summary>
+		// Token: 0x04001923 RID: 6435
+		[Token(Token = "0x4001923")]
+		WillNotCorruptState
+	}
+}

mscorlib/System/Runtime/ConstrainedExecution/CriticalFinalizerObject.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Runtime.InteropServices;
+using Cpp2IlInjected;
+
+namespace System.Runtime.ConstrainedExecution
+{
+	/// <summary>Ensures that all finalization code in derived classes is marked as critical.</summary>
+	// Token: 0x02000547 RID: 1351
+	[Token(Token = "0x2000547")]
+	[ComVisible(true)]
+	public abstract class CriticalFinalizerObject
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.ConstrainedExecution.CriticalFinalizerObject" /> class.</summary>
+		// Token: 0x06002C01 RID: 11265 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C01")]
+		[Address(RVA = "0x412370", Offset = "0x411370", VA = "0x180412370")]
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
+		protected CriticalFinalizerObject()
+		{
+		}
+
+		/// <summary>Releases all the resources used by the <see cref="T:System.Runtime.ConstrainedExecution.CriticalFinalizerObject" /> class.</summary>
+		// Token: 0x06002C02 RID: 11266 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C02")]
+		[Address(RVA = "0x2CEC740", Offset = "0x2CEB740", VA = "0x182CEC740", Slot = "1")]
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
+		protected override void Finalize()
+		{
+		}
+	}
+}

mscorlib/System/Runtime/ConstrainedExecution/PrePrepareMethodAttribute.cs

@@ -0,0 +1,20 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.ConstrainedExecution
+{
+	/// <summary>Instructs the native image generation service to prepare a method for inclusion in a constrained execution region (CER).</summary>
+	// Token: 0x02000548 RID: 1352
+	[Token(Token = "0x2000548")]
+	[AttributeUsage(AttributeTargets.Constructor | AttributeTargets.Method)]
+	public sealed class PrePrepareMethodAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.ConstrainedExecution.PrePrepareMethodAttribute" /> class.</summary>
+		// Token: 0x06002C03 RID: 11267 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C03")]
+		[Address(RVA = "0x42BA20", Offset = "0x42AA20", VA = "0x18042BA20")]
+		public PrePrepareMethodAttribute()
+		{
+		}
+	}
+}

mscorlib/System/Runtime/ConstrainedExecution/ReliabilityContractAttribute.cs

@@ -0,0 +1,32 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.ConstrainedExecution
+{
+	/// <summary>Defines a contract for reliability between the author of some code, and the developers who have a dependency on that code.</summary>
+	// Token: 0x0200054B RID: 1355
+	[Token(Token = "0x200054B")]
+	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Interface)]
+	public sealed class ReliabilityContractAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.ConstrainedExecution.ReliabilityContractAttribute" /> class with the specified <see cref="T:System.Runtime.ConstrainedExecution.Consistency" /> guarantee and <see cref="T:System.Runtime.ConstrainedExecution.Cer" /> value.</summary>
+		/// <param name="consistencyGuarantee">One of the <see cref="T:System.Runtime.ConstrainedExecution.Consistency" /> values.</param>
+		/// <param name="cer">One of the <see cref="T:System.Runtime.ConstrainedExecution.Cer" /> values.</param>
+		// Token: 0x06002C04 RID: 11268 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C04")]
+		[Address(RVA = "0x2CF3C60", Offset = "0x2CF2C60", VA = "0x182CF3C60")]
+		public ReliabilityContractAttribute(Consistency consistencyGuarantee, Cer cer)
+		{
+		}
+
+		// Token: 0x04001928 RID: 6440
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x4001928")]
+		private Consistency _consistency;
+
+		// Token: 0x04001929 RID: 6441
+		[FieldOffset(Offset = "0x14")]
+		[Token(Token = "0x4001929")]
+		private Cer _cer;
+	}
+}

mscorlib/System/Runtime/ExceptionServices/ExceptionDispatchInfo.cs

@@ -0,0 +1,84 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.ExceptionServices
+{
+	/// <summary>Represents an exception whose state is captured at a certain point in code.</summary>
+	// Token: 0x02000546 RID: 1350
+	[Token(Token = "0x2000546")]
+	public sealed class ExceptionDispatchInfo
+	{
+		// Token: 0x06002BFB RID: 11259 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002BFB")]
+		[Address(RVA = "0x2CEDD40", Offset = "0x2CECD40", VA = "0x182CEDD40")]
+		private ExceptionDispatchInfo(Exception exception)
+		{
+		}
+
+		// Token: 0x170006B0 RID: 1712
+		// (get) Token: 0x06002BFC RID: 11260 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x170006B0")]
+		internal object BinaryStackTraceArray
+		{
+			[Token(Token = "0x6002BFC")]
+			[Address(RVA = "0x4157B0", Offset = "0x4147B0", VA = "0x1804157B0")]
+			get
+			{
+				return null;
+			}
+		}
+
+		/// <summary>Creates an <see cref="T:System.Runtime.ExceptionServices.ExceptionDispatchInfo" /> object that represents the specified exception at the current point in code.</summary>
+		/// <param name="source">The exception whose state is captured, and which is represented by the returned object.</param>
+		/// <returns>An object that represents the specified exception at the current point in code.</returns>
+		/// <exception cref="T:System.ArgumentException">
+		///   <paramref name="source" /> is <see langword="null" />.</exception>
+		// Token: 0x06002BFD RID: 11261 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002BFD")]
+		[Address(RVA = "0x2CEDAF0", Offset = "0x2CECAF0", VA = "0x182CEDAF0")]
+		public static ExceptionDispatchInfo Capture(Exception source)
+		{
+			return null;
+		}
+
+		/// <summary>Gets the exception that is represented by the current instance.</summary>
+		/// <returns>The exception that is represented by the current instance.</returns>
+		// Token: 0x170006B1 RID: 1713
+		// (get) Token: 0x06002BFE RID: 11262 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x170006B1")]
+		public Exception SourceException
+		{
+			[Token(Token = "0x6002BFE")]
+			[Address(RVA = "0x411530", Offset = "0x410530", VA = "0x180411530")]
+			get
+			{
+				return null;
+			}
+		}
+
+		/// <summary>Throws the exception that is represented by the current <see cref="T:System.Runtime.ExceptionServices.ExceptionDispatchInfo" /> object, after restoring the state that was saved when the exception was captured.</summary>
+		// Token: 0x06002BFF RID: 11263 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002BFF")]
+		[Address(RVA = "0x2CEDCA0", Offset = "0x2CECCA0", VA = "0x182CEDCA0")]
+		public void Throw()
+		{
+		}
+
+		// Token: 0x06002C00 RID: 11264 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002C00")]
+		[Address(RVA = "0x2CEDD10", Offset = "0x2CECD10", VA = "0x182CEDD10")]
+		public static void Throw(Exception source)
+		{
+		}
+
+		// Token: 0x0400191D RID: 6429
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x400191D")]
+		private Exception m_Exception;
+
+		// Token: 0x0400191E RID: 6430
+		[FieldOffset(Offset = "0x18")]
+		[Token(Token = "0x400191E")]
+		private object m_stackTrace;
+	}
+}

mscorlib/System/Runtime/ExceptionServices/FirstChanceExceptionEventArgs.cs

@@ -0,0 +1,12 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.ExceptionServices
+{
+	/// <summary>Provides data for the notification event that is raised when a managed exception first occurs, before the common language runtime begins searching for event handlers.</summary>
+	// Token: 0x02000545 RID: 1349
+	[Token(Token = "0x2000545")]
+	public class FirstChanceExceptionEventArgs : EventArgs
+	{
+	}
+}

mscorlib/System/Runtime/ExceptionServices/HandleProcessCorruptedStateExceptionsAttribute.cs

@@ -0,0 +1,20 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.ExceptionServices
+{
+	/// <summary>Enables managed code to handle exceptions that indicate a corrupted process state.</summary>
+	// Token: 0x02000544 RID: 1348
+	[Token(Token = "0x2000544")]
+	[AttributeUsage(AttributeTargets.Method)]
+	public sealed class HandleProcessCorruptedStateExceptionsAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.ExceptionServices.HandleProcessCorruptedStateExceptionsAttribute" /> class.</summary>
+		// Token: 0x06002BFA RID: 11258 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002BFA")]
+		[Address(RVA = "0x42BA20", Offset = "0x42AA20", VA = "0x18042BA20")]
+		public HandleProcessCorruptedStateExceptionsAttribute()
+		{
+		}
+	}
+}

mscorlib/System/Runtime/InteropServices/COMException.cs

@@ -0,0 +1,54 @@
+using System;
+using System.Runtime.Serialization;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>The exception that is thrown when an unrecognized HRESULT is returned from a COM method call.</summary>
+	// Token: 0x0200059B RID: 1435
+	[Token(Token = "0x200059B")]
+	[ComVisible(true)]
+	[Serializable]
+	public class COMException : ExternalException
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.InteropServices.COMException" /> class with default values.</summary>
+		// Token: 0x06002CBE RID: 11454 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CBE")]
+		[Address(RVA = "0x2CE9310", Offset = "0x2CE8310", VA = "0x182CE9310")]
+		public COMException()
+		{
+		}
+
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.InteropServices.COMException" /> class with a specified message and error code.</summary>
+		/// <param name="message">The message that indicates the reason the exception occurred.</param>
+		/// <param name="errorCode">The error code (HRESULT) value associated with this exception.</param>
+		// Token: 0x06002CBF RID: 11455 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CBF")]
+		[Address(RVA = "0x2CE9380", Offset = "0x2CE8380", VA = "0x182CE9380")]
+		public COMException(string message, int errorCode)
+		{
+		}
+
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.InteropServices.COMException" /> class from serialization data.</summary>
+		/// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo" /> object that holds the serialized object data.</param>
+		/// <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext" /> object that supplies the contextual information about the source or destination.</param>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="info" /> is <see langword="null" />.</exception>
+		// Token: 0x06002CC0 RID: 11456 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CC0")]
+		[Address(RVA = "0x7241B0", Offset = "0x7231B0", VA = "0x1807241B0")]
+		protected COMException(SerializationInfo info, StreamingContext context)
+		{
+		}
+
+		/// <summary>Converts the contents of the exception to a string.</summary>
+		/// <returns>A string containing the <see cref="P:System.Exception.HResult" />, <see cref="P:System.Exception.Message" />, <see cref="P:System.Exception.InnerException" />, and <see cref="P:System.Exception.StackTrace" /> properties of the exception.</returns>
+		// Token: 0x06002CC1 RID: 11457 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002CC1")]
+		[Address(RVA = "0x2CE9170", Offset = "0x2CE8170", VA = "0x182CE9170", Slot = "3")]
+		public override string ToString()
+		{
+			return null;
+		}
+	}
+}

mscorlib/System/Runtime/InteropServices/CallingConvention.cs

@@ -0,0 +1,34 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Specifies the calling convention required to call methods implemented in unmanaged code.</summary>
+	// Token: 0x02000599 RID: 1433
+	[Token(Token = "0x2000599")]
+	[ComVisible(true)]
+	[Serializable]
+	public enum CallingConvention
+	{
+		/// <summary>This member is not actually a calling convention, but instead uses the default platform calling convention. For example, on Windows the default is <see cref="F:System.Runtime.InteropServices.CallingConvention.StdCall" /> and on Windows CE.NET it is <see cref="F:System.Runtime.InteropServices.CallingConvention.Cdecl" />.</summary>
+		// Token: 0x040019EB RID: 6635
+		[Token(Token = "0x40019EB")]
+		Winapi = 1,
+		/// <summary>The caller cleans the stack. This enables calling functions with <see langword="varargs" />, which makes it appropriate to use for methods that accept a variable number of parameters, such as <see langword="Printf" />.</summary>
+		// Token: 0x040019EC RID: 6636
+		[Token(Token = "0x40019EC")]
+		Cdecl,
+		/// <summary>The callee cleans the stack. This is the default convention for calling unmanaged functions with platform invoke.</summary>
+		// Token: 0x040019ED RID: 6637
+		[Token(Token = "0x40019ED")]
+		StdCall,
+		/// <summary>The first parameter is the <see langword="this" /> pointer and is stored in register ECX. Other parameters are pushed on the stack. This calling convention is used to call methods on classes exported from an unmanaged DLL.</summary>
+		// Token: 0x040019EE RID: 6638
+		[Token(Token = "0x40019EE")]
+		ThisCall,
+		/// <summary>This calling convention is not supported.</summary>
+		// Token: 0x040019EF RID: 6639
+		[Token(Token = "0x40019EF")]
+		FastCall
+	}
+}

mscorlib/System/Runtime/InteropServices/CharSet.cs

@@ -0,0 +1,30 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Dictates which character set marshaled strings should use.</summary>
+	// Token: 0x0200059A RID: 1434
+	[Token(Token = "0x200059A")]
+	[ComVisible(true)]
+	[Serializable]
+	public enum CharSet
+	{
+		/// <summary>This value is obsolete and has the same behavior as <see cref="F:System.Runtime.InteropServices.CharSet.Ansi" />.</summary>
+		// Token: 0x040019F1 RID: 6641
+		[Token(Token = "0x40019F1")]
+		None = 1,
+		/// <summary>Marshal strings as multiple-byte character strings.</summary>
+		// Token: 0x040019F2 RID: 6642
+		[Token(Token = "0x40019F2")]
+		Ansi,
+		/// <summary>Marshal strings as Unicode 2-byte characters.</summary>
+		// Token: 0x040019F3 RID: 6643
+		[Token(Token = "0x40019F3")]
+		Unicode,
+		/// <summary>Automatically marshal strings appropriately for the target operating system. The default is <see cref="F:System.Runtime.InteropServices.CharSet.Unicode" /> on Windows NT, Windows 2000, Windows XP, and the Windows Server 2003 family; the default is <see cref="F:System.Runtime.InteropServices.CharSet.Ansi" /> on Windows 98 and Windows Me. Although the common language runtime default is <see cref="F:System.Runtime.InteropServices.CharSet.Auto" />, languages may override this default. For example, by default C# marks all methods and types as <see cref="F:System.Runtime.InteropServices.CharSet.Ansi" />.</summary>
+		// Token: 0x040019F4 RID: 6644
+		[Token(Token = "0x40019F4")]
+		Auto
+	}
+}

mscorlib/System/Runtime/InteropServices/ClassInterfaceAttribute.cs

@@ -0,0 +1,27 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Indicates the type of class interface to be generated for a class exposed to COM, if an interface is generated at all.</summary>
+	// Token: 0x0200058A RID: 1418
+	[Token(Token = "0x200058A")]
+	[ComVisible(true)]
+	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class)]
+	public sealed class ClassInterfaceAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.InteropServices.ClassInterfaceAttribute" /> class with the specified <see cref="T:System.Runtime.InteropServices.ClassInterfaceType" /> enumeration member.</summary>
+		/// <param name="classInterfaceType">One of the <see cref="T:System.Runtime.InteropServices.ClassInterfaceType" /> values that describes the type of interface that is generated for a class.</param>
+		// Token: 0x06002CAD RID: 11437 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CAD")]
+		[Address(RVA = "0x41F8E0", Offset = "0x41E8E0", VA = "0x18041F8E0")]
+		public ClassInterfaceAttribute(ClassInterfaceType classInterfaceType)
+		{
+		}
+
+		// Token: 0x0400197C RID: 6524
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x400197C")]
+		internal ClassInterfaceType _val;
+	}
+}

mscorlib/System/Runtime/InteropServices/ClassInterfaceType.cs

@@ -0,0 +1,26 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Identifies the type of class interface that is generated for a class.</summary>
+	// Token: 0x02000589 RID: 1417
+	[Token(Token = "0x2000589")]
+	[ComVisible(true)]
+	[Serializable]
+	public enum ClassInterfaceType
+	{
+		/// <summary>Indicates that no class interface is generated for the class. If no interfaces are implemented explicitly, the class can only provide late-bound access through the <see langword="IDispatch" /> interface. This is the recommended setting for <see cref="T:System.Runtime.InteropServices.ClassInterfaceAttribute" />. Using <see langword="ClassInterfaceType.None" /> is the only way to expose functionality through interfaces implemented explicitly by the class.</summary>
+		// Token: 0x04001979 RID: 6521
+		[Token(Token = "0x4001979")]
+		None,
+		/// <summary>Indicates that the class only supports late binding for COM clients. A <see langword="dispinterface" /> for the class is automatically exposed to COM clients on request. The type library produced by Tlbexp.exe (Type Library Exporter) does not contain type information for the <see langword="dispinterface" /> in order to prevent clients from caching the DISPIDs of the interface. The <see langword="dispinterface" /> does not exhibit the versioning problems described in <see cref="T:System.Runtime.InteropServices.ClassInterfaceAttribute" /> because clients can only late-bind to the interface.</summary>
+		// Token: 0x0400197A RID: 6522
+		[Token(Token = "0x400197A")]
+		AutoDispatch,
+		/// <summary>Indicates that a dual class interface is automatically generated for the class and exposed to COM. Type information is produced for the class interface and published in the type library. Using <see langword="AutoDual" /> is strongly discouraged because of the versioning limitations described in <see cref="T:System.Runtime.InteropServices.ClassInterfaceAttribute" />.</summary>
+		// Token: 0x0400197B RID: 6523
+		[Token(Token = "0x400197B")]
+		AutoDual
+	}
+}

mscorlib/System/Runtime/InteropServices/ComCompatibleVersionAttribute.cs

@@ -0,0 +1,45 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Indicates to a COM client that all classes in the current version of an assembly are compatible with classes in an earlier version of the assembly.</summary>
+	// Token: 0x02000598 RID: 1432
+	[Token(Token = "0x2000598")]
+	[AttributeUsage(AttributeTargets.Assembly)]
+	[ComVisible(true)]
+	public sealed class ComCompatibleVersionAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.InteropServices.ComCompatibleVersionAttribute" /> class with the major version, minor version, build, and revision numbers of the assembly.</summary>
+		/// <param name="major">The major version number of the assembly.</param>
+		/// <param name="minor">The minor version number of the assembly.</param>
+		/// <param name="build">The build number of the assembly.</param>
+		/// <param name="revision">The revision number of the assembly.</param>
+		// Token: 0x06002CBD RID: 11453 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CBD")]
+		[Address(RVA = "0x2CEC290", Offset = "0x2CEB290", VA = "0x182CEC290")]
+		public ComCompatibleVersionAttribute(int major, int minor, int build, int revision)
+		{
+		}
+
+		// Token: 0x040019E6 RID: 6630
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x40019E6")]
+		internal int _major;
+
+		// Token: 0x040019E7 RID: 6631
+		[FieldOffset(Offset = "0x14")]
+		[Token(Token = "0x40019E7")]
+		internal int _minor;
+
+		// Token: 0x040019E8 RID: 6632
+		[FieldOffset(Offset = "0x18")]
+		[Token(Token = "0x40019E8")]
+		internal int _build;
+
+		// Token: 0x040019E9 RID: 6633
+		[FieldOffset(Offset = "0x1C")]
+		[Token(Token = "0x40019E9")]
+		internal int _revision;
+	}
+}

mscorlib/System/Runtime/InteropServices/ComDefaultInterfaceAttribute.cs

@@ -0,0 +1,27 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Specifies a default interface to expose to COM. This class cannot be inherited.</summary>
+	// Token: 0x02000588 RID: 1416
+	[Token(Token = "0x2000588")]
+	[ComVisible(true)]
+	[AttributeUsage(AttributeTargets.Class)]
+	public sealed class ComDefaultInterfaceAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.InteropServices.ComDefaultInterfaceAttribute" /> class with the specified <see cref="T:System.Type" /> object as the default interface exposed to COM.</summary>
+		/// <param name="defaultInterface">A <see cref="T:System.Type" /> value indicating the default interface to expose to COM.</param>
+		// Token: 0x06002CAC RID: 11436 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CAC")]
+		[Address(RVA = "0x681CA0", Offset = "0x680CA0", VA = "0x180681CA0")]
+		public ComDefaultInterfaceAttribute(Type defaultInterface)
+		{
+		}
+
+		// Token: 0x04001977 RID: 6519
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x4001977")]
+		internal Type _val;
+	}
+}

mscorlib/System/Runtime/InteropServices/ComImportAttribute.cs

@@ -0,0 +1,21 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Indicates that the attributed type was previously defined in COM.</summary>
+	// Token: 0x0200058E RID: 1422
+	[Token(Token = "0x200058E")]
+	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface)]
+	[ComVisible(true)]
+	public sealed class ComImportAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.InteropServices.ComImportAttribute" />.</summary>
+		// Token: 0x06002CAF RID: 11439 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CAF")]
+		[Address(RVA = "0x42BA20", Offset = "0x42AA20", VA = "0x18042BA20")]
+		public ComImportAttribute()
+		{
+		}
+	}
+}

mscorlib/System/Runtime/InteropServices/ComInterfaceType.cs

@@ -0,0 +1,31 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Identifies how to expose an interface to COM.</summary>
+	// Token: 0x02000586 RID: 1414
+	[Token(Token = "0x2000586")]
+	[ComVisible(true)]
+	[Serializable]
+	public enum ComInterfaceType
+	{
+		/// <summary>Indicates that the interface is exposed to COM as a dual interface, which enables both early and late binding. <see cref="F:System.Runtime.InteropServices.ComInterfaceType.InterfaceIsDual" /> is the default value.</summary>
+		// Token: 0x04001972 RID: 6514
+		[Token(Token = "0x4001972")]
+		InterfaceIsDual,
+		/// <summary>Indicates that an interface is exposed to COM as an interface that is derived from IUnknown, which enables only early binding.</summary>
+		// Token: 0x04001973 RID: 6515
+		[Token(Token = "0x4001973")]
+		InterfaceIsIUnknown,
+		/// <summary>Indicates that an interface is exposed to COM as a dispinterface, which enables late binding only.</summary>
+		// Token: 0x04001974 RID: 6516
+		[Token(Token = "0x4001974")]
+		InterfaceIsIDispatch,
+		/// <summary>Indicates that an interface is exposed to COM as a Windows Runtime interface.</summary>
+		// Token: 0x04001975 RID: 6517
+		[Token(Token = "0x4001975")]
+		[ComVisible(false)]
+		InterfaceIsIInspectable
+	}
+}

mscorlib/System/Runtime/InteropServices/ComTypes/FILETIME.cs

@@ -0,0 +1,23 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices.ComTypes
+{
+	/// <summary>Represents the number of 100-nanosecond intervals since January 1, 1601. This structure is a 64-bit value.</summary>
+	// Token: 0x020005B9 RID: 1465
+	[Token(Token = "0x20005B9")]
+	public struct FILETIME
+	{
+		/// <summary>Specifies the low 32 bits of the <see langword="FILETIME" />.</summary>
+		// Token: 0x04001A11 RID: 6673
+		[FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x4001A11")]
+		public int dwLowDateTime;
+
+		/// <summary>Specifies the high 32 bits of the <see langword="FILETIME" />.</summary>
+		// Token: 0x04001A12 RID: 6674
+		[FieldOffset(Offset = "0x4")]
+		[Token(Token = "0x4001A12")]
+		public int dwHighDateTime;
+	}
+}

mscorlib/System/Runtime/InteropServices/ComTypes/IStream.cs

@@ -0,0 +1,104 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices.ComTypes
+{
+	/// <summary>Provides the managed definition of the <see langword="IStream" /> interface, with <see langword="ISequentialStream" /> functionality.</summary>
+	// Token: 0x020005BB RID: 1467
+	[Token(Token = "0x20005BB")]
+	[Guid("0000000c-0000-0000-C000-000000000046")]
+	[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+	[ComImport]
+	public interface IStream
+	{
+		/// <summary>Reads a specified number of bytes from the stream object into memory starting at the current seek pointer.</summary>
+		/// <param name="pv">When this method returns, contains the data read from the stream. This parameter is passed uninitialized.</param>
+		/// <param name="cb">The number of bytes to read from the stream object.</param>
+		/// <param name="pcbRead">A pointer to a <see langword="ULONG" /> variable that receives the actual number of bytes read from the stream object.</param>
+		// Token: 0x06002D4D RID: 11597
+		[Token(Token = "0x6002D4D")]
+		[Address(RVA = "0x2CEE740", Offset = "0x2CED740", VA = "0x182CEE740", Slot = "0")]
+		void Read([Out] byte[] pv, int cb, IntPtr pcbRead);
+
+		/// <summary>Writes a specified number of bytes into the stream object starting at the current seek pointer.</summary>
+		/// <param name="pv">The buffer to write this stream to.</param>
+		/// <param name="cb">The number of bytes to write to the stream.</param>
+		/// <param name="pcbWritten">On successful return, contains the actual number of bytes written to the stream object. If the caller sets this pointer to <see cref="F:System.IntPtr.Zero" />, this method does not provide the actual number of bytes written.</param>
+		// Token: 0x06002D4E RID: 11598
+		[Token(Token = "0x6002D4E")]
+		[Address(RVA = "0x2CEEA50", Offset = "0x2CEDA50", VA = "0x182CEEA50", Slot = "1")]
+		void Write(byte[] pv, int cb, IntPtr pcbWritten);
+
+		/// <summary>Changes the seek pointer to a new location relative to the beginning of the stream, to the end of the stream, or to the current seek pointer.</summary>
+		/// <param name="dlibMove">The displacement to add to <paramref name="dwOrigin" />.</param>
+		/// <param name="dwOrigin">The origin of the seek. The origin can be the beginning of the file, the current seek pointer, or the end of the file.</param>
+		/// <param name="plibNewPosition">On successful return, contains the offset of the seek pointer from the beginning of the stream.</param>
+		// Token: 0x06002D4F RID: 11599
+		[Token(Token = "0x6002D4F")]
+		[Address(RVA = "0x2CEE840", Offset = "0x2CED840", VA = "0x182CEE840", Slot = "2")]
+		void Seek(long dlibMove, int dwOrigin, IntPtr plibNewPosition);
+
+		/// <summary>Changes the size of the stream object.</summary>
+		/// <param name="libNewSize">The new size of the stream as a number of bytes.</param>
+		// Token: 0x06002D50 RID: 11600
+		[Token(Token = "0x6002D50")]
+		[Address(RVA = "0x2CEE8A0", Offset = "0x2CED8A0", VA = "0x182CEE8A0", Slot = "3")]
+		void SetSize(long libNewSize);
+
+		/// <summary>Copies a specified number of bytes from the current seek pointer in the stream to the current seek pointer in another stream.</summary>
+		/// <param name="pstm">A reference to the destination stream.</param>
+		/// <param name="cb">The number of bytes to copy from the source stream.</param>
+		/// <param name="pcbRead">On successful return, contains the actual number of bytes read from the source.</param>
+		/// <param name="pcbWritten">On successful return, contains the actual number of bytes written to the destination.</param>
+		// Token: 0x06002D51 RID: 11601
+		[Token(Token = "0x6002D51")]
+		[Address(RVA = "0x2CEE630", Offset = "0x2CED630", VA = "0x182CEE630", Slot = "4")]
+		void CopyTo(IStream pstm, long cb, IntPtr pcbRead, IntPtr pcbWritten);
+
+		/// <summary>Ensures that any changes made to a stream object that is open in transacted mode are reflected in the parent storage.</summary>
+		/// <param name="grfCommitFlags">A value that controls how the changes for the stream object are committed.</param>
+		// Token: 0x06002D52 RID: 11602
+		[Token(Token = "0x6002D52")]
+		[Address(RVA = "0x2CEE5F0", Offset = "0x2CED5F0", VA = "0x182CEE5F0", Slot = "5")]
+		void Commit(int grfCommitFlags);
+
+		/// <summary>Discards all changes that have been made to a transacted stream since the last <see cref="M:System.Runtime.InteropServices.ComTypes.IStream.Commit(System.Int32)" /> call.</summary>
+		// Token: 0x06002D53 RID: 11603
+		[Token(Token = "0x6002D53")]
+		[Address(RVA = "0x2CEE810", Offset = "0x2CED810", VA = "0x182CEE810", Slot = "6")]
+		void Revert();
+
+		/// <summary>Restricts access to a specified range of bytes in the stream.</summary>
+		/// <param name="libOffset">The byte offset for the beginning of the range.</param>
+		/// <param name="cb">The length of the range, in bytes, to restrict.</param>
+		/// <param name="dwLockType">The requested restrictions on accessing the range.</param>
+		// Token: 0x06002D54 RID: 11604
+		[Token(Token = "0x6002D54")]
+		[Address(RVA = "0x2CEE6E0", Offset = "0x2CED6E0", VA = "0x182CEE6E0", Slot = "7")]
+		void LockRegion(long libOffset, long cb, int dwLockType);
+
+		/// <summary>Removes the access restriction on a range of bytes previously restricted with the <see cref="M:System.Runtime.InteropServices.ComTypes.IStream.LockRegion(System.Int64,System.Int64,System.Int32)" /> method.</summary>
+		/// <param name="libOffset">The byte offset for the beginning of the range.</param>
+		/// <param name="cb">The length, in bytes, of the range to restrict.</param>
+		/// <param name="dwLockType">The access restrictions previously placed on the range.</param>
+		// Token: 0x06002D55 RID: 11605
+		[Token(Token = "0x6002D55")]
+		[Address(RVA = "0x2CEE9F0", Offset = "0x2CED9F0", VA = "0x182CEE9F0", Slot = "8")]
+		void UnlockRegion(long libOffset, long cb, int dwLockType);
+
+		/// <summary>Retrieves the <see cref="T:System.Runtime.InteropServices.STATSTG" /> structure for this stream.</summary>
+		/// <param name="pstatstg">When this method returns, contains a <see langword="STATSTG" /> structure that describes this stream object. This parameter is passed uninitialized.</param>
+		/// <param name="grfStatFlag">Members in the <see langword="STATSTG" /> structure that this method does not return, thus saving some memory allocation operations.</param>
+		// Token: 0x06002D56 RID: 11606
+		[Token(Token = "0x6002D56")]
+		[Address(RVA = "0x2CEE8E0", Offset = "0x2CED8E0", VA = "0x182CEE8E0", Slot = "9")]
+		void Stat(out STATSTG pstatstg, int grfStatFlag);
+
+		/// <summary>Creates a new stream object with its own seek pointer that references the same bytes as the original stream.</summary>
+		/// <param name="ppstm">When this method returns, contains the new stream object. This parameter is passed uninitialized.</param>
+		// Token: 0x06002D57 RID: 11607
+		[Token(Token = "0x6002D57")]
+		[Address(RVA = "0x2CEE530", Offset = "0x2CED530", VA = "0x182CEE530", Slot = "10")]
+		void Clone(out IStream ppstm);
+	}
+}

mscorlib/System/Runtime/InteropServices/ComTypes/STATSTG.cs

@@ -0,0 +1,78 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices.ComTypes
+{
+	/// <summary>Contains statistical information about an open storage, stream, or byte-array object.</summary>
+	// Token: 0x020005BA RID: 1466
+	[Token(Token = "0x20005BA")]
+	[StructLayout(0, CharSet = CharSet.Unicode)]
+	public struct STATSTG
+	{
+		/// <summary>Represents a pointer to a null-terminated string containing the name of the object described by this structure.</summary>
+		// Token: 0x04001A13 RID: 6675
+		[FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x4001A13")]
+		public string pwcsName;
+
+		/// <summary>Indicates the type of storage object, which is one of the values from the <see langword="STGTY" /> enumeration.</summary>
+		// Token: 0x04001A14 RID: 6676
+		[FieldOffset(Offset = "0x8")]
+		[Token(Token = "0x4001A14")]
+		public int type;
+
+		/// <summary>Specifies the size, in bytes, of the stream or byte array.</summary>
+		// Token: 0x04001A15 RID: 6677
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x4001A15")]
+		public long cbSize;
+
+		/// <summary>Indicates the last modification time for this storage, stream, or byte array.</summary>
+		// Token: 0x04001A16 RID: 6678
+		[FieldOffset(Offset = "0x18")]
+		[Token(Token = "0x4001A16")]
+		public FILETIME mtime;
+
+		/// <summary>Indicates the creation time for this storage, stream, or byte array.</summary>
+		// Token: 0x04001A17 RID: 6679
+		[FieldOffset(Offset = "0x20")]
+		[Token(Token = "0x4001A17")]
+		public FILETIME ctime;
+
+		/// <summary>Specifies the last access time for this storage, stream, or byte array.</summary>
+		// Token: 0x04001A18 RID: 6680
+		[FieldOffset(Offset = "0x28")]
+		[Token(Token = "0x4001A18")]
+		public FILETIME atime;
+
+		/// <summary>Indicates the access mode that was specified when the object was opened.</summary>
+		// Token: 0x04001A19 RID: 6681
+		[FieldOffset(Offset = "0x30")]
+		[Token(Token = "0x4001A19")]
+		public int grfMode;
+
+		/// <summary>Indicates the types of region locking supported by the stream or byte array.</summary>
+		// Token: 0x04001A1A RID: 6682
+		[FieldOffset(Offset = "0x34")]
+		[Token(Token = "0x4001A1A")]
+		public int grfLocksSupported;
+
+		/// <summary>Indicates the class identifier for the storage object.</summary>
+		// Token: 0x04001A1B RID: 6683
+		[FieldOffset(Offset = "0x38")]
+		[Token(Token = "0x4001A1B")]
+		public Guid clsid;
+
+		/// <summary>Indicates the current state bits of the storage object (the value most recently set by the <see langword="IStorage::SetStateBits" /> method).</summary>
+		// Token: 0x04001A1C RID: 6684
+		[FieldOffset(Offset = "0x48")]
+		[Token(Token = "0x4001A1C")]
+		public int grfStateBits;
+
+		/// <summary>Reserved for future use.</summary>
+		// Token: 0x04001A1D RID: 6685
+		[FieldOffset(Offset = "0x4C")]
+		[Token(Token = "0x4001A1D")]
+		public int reserved;
+	}
+}

mscorlib/System/Runtime/InteropServices/ComVisibleAttribute.cs

@@ -0,0 +1,28 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Controls accessibility of an individual managed type or member, or of all types within an assembly, to COM.</summary>
+	// Token: 0x0200058B RID: 1419
+	[Token(Token = "0x200058B")]
+	[ComVisible(true)]
+	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Interface | AttributeTargets.Delegate)]
+	public sealed class ComVisibleAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see langword="ComVisibleAttribute" /> class.</summary>
+		/// <param name="visibility">
+		///   <see langword="true" /> to indicate that the type is visible to COM; otherwise, <see langword="false" />. The default is <see langword="true" />.</param>
+		// Token: 0x06002CAE RID: 11438 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CAE")]
+		[Address(RVA = "0xB9AFE0", Offset = "0xB99FE0", VA = "0x180B9AFE0")]
+		public ComVisibleAttribute(bool visibility)
+		{
+		}
+
+		// Token: 0x0400197D RID: 6525
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x400197D")]
+		internal bool _val;
+	}
+}

mscorlib/System/Runtime/InteropServices/DefaultDllImportSearchPathsAttribute.cs

@@ -0,0 +1,27 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Specifies the paths that are used to search for DLLs that provide functions for platform invokes.</summary>
+	// Token: 0x02000595 RID: 1429
+	[Token(Token = "0x2000595")]
+	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Method)]
+	[ComVisible(false)]
+	public sealed class DefaultDllImportSearchPathsAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.InteropServices.DefaultDllImportSearchPathsAttribute" /> class, specifying the paths to use when searching for the targets of platform invokes.</summary>
+		/// <param name="paths">A bitwise combination of enumeration values that specify the paths that the LoadLibraryEx function searches during platform invokes.</param>
+		// Token: 0x06002CB6 RID: 11446 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CB6")]
+		[Address(RVA = "0x41F8E0", Offset = "0x41E8E0", VA = "0x18041F8E0")]
+		public DefaultDllImportSearchPathsAttribute(DllImportSearchPath paths)
+		{
+		}
+
+		// Token: 0x040019DB RID: 6619
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x40019DB")]
+		internal DllImportSearchPath _paths;
+	}
+}

mscorlib/System/Runtime/InteropServices/DispIdAttribute.cs

@@ -0,0 +1,27 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Specifies the COM dispatch identifier (DISPID) of a method, field, or property.</summary>
+	// Token: 0x02000585 RID: 1413
+	[Token(Token = "0x2000585")]
+	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event)]
+	[ComVisible(true)]
+	public sealed class DispIdAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see langword="DispIdAttribute" /> class with the specified DISPID.</summary>
+		/// <param name="dispId">The DISPID for the member.</param>
+		// Token: 0x06002CAA RID: 11434 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CAA")]
+		[Address(RVA = "0x41F8E0", Offset = "0x41E8E0", VA = "0x18041F8E0")]
+		public DispIdAttribute(int dispId)
+		{
+		}
+
+		// Token: 0x04001970 RID: 6512
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x4001970")]
+		internal int _val;
+	}
+}

mscorlib/System/Runtime/InteropServices/DllImportAttribute.cs

@@ -0,0 +1,114 @@
+using System;
+using System.Reflection;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Indicates that the attributed method is exposed by an unmanaged dynamic-link library (DLL) as a static entry point.</summary>
+	// Token: 0x02000596 RID: 1430
+	[Token(Token = "0x2000596")]
+	[AttributeUsage(AttributeTargets.Method)]
+	[ComVisible(true)]
+	public sealed class DllImportAttribute : Attribute
+	{
+		// Token: 0x06002CB7 RID: 11447 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002CB7")]
+		[Address(RVA = "0x2CED790", Offset = "0x2CEC790", VA = "0x182CED790")]
+		internal static Attribute GetCustomAttribute(RuntimeMethodInfo method)
+		{
+			return null;
+		}
+
+		// Token: 0x06002CB8 RID: 11448 RVA: 0x00018DF8 File Offset: 0x00016FF8
+		[Token(Token = "0x6002CB8")]
+		[Address(RVA = "0x2CEDA40", Offset = "0x2CECA40", VA = "0x182CEDA40")]
+		internal static bool IsDefined(RuntimeMethodInfo method)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x06002CB9 RID: 11449 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CB9")]
+		[Address(RVA = "0x2CEDA70", Offset = "0x2CECA70", VA = "0x182CEDA70")]
+		internal DllImportAttribute(string dllName, string entryPoint, CharSet charSet, bool exactSpelling, bool setLastError, bool preserveSig, CallingConvention callingConvention, bool bestFitMapping, bool throwOnUnmappableChar)
+		{
+		}
+
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.InteropServices.DllImportAttribute" /> class with the name of the DLL containing the method to import.</summary>
+		/// <param name="dllName">The name of the DLL that contains the unmanaged method. This can include an assembly display name, if the DLL is included in an assembly.</param>
+		// Token: 0x06002CBA RID: 11450 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CBA")]
+		[Address(RVA = "0x681CA0", Offset = "0x680CA0", VA = "0x180681CA0")]
+		public DllImportAttribute(string dllName)
+		{
+		}
+
+		/// <summary>Gets the name of the DLL file that contains the entry point.</summary>
+		/// <returns>The name of the DLL file that contains the entry point.</returns>
+		// Token: 0x170006C8 RID: 1736
+		// (get) Token: 0x06002CBB RID: 11451 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x170006C8")]
+		public string Value
+		{
+			[Token(Token = "0x6002CBB")]
+			[Address(RVA = "0x411530", Offset = "0x410530", VA = "0x180411530")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x040019DC RID: 6620
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x40019DC")]
+		internal string _val;
+
+		/// <summary>Indicates the name or ordinal of the DLL entry point to be called.</summary>
+		// Token: 0x040019DD RID: 6621
+		[FieldOffset(Offset = "0x18")]
+		[Token(Token = "0x40019DD")]
+		public string EntryPoint;
+
+		/// <summary>Indicates how to marshal string parameters to the method and controls name mangling.</summary>
+		// Token: 0x040019DE RID: 6622
+		[FieldOffset(Offset = "0x20")]
+		[Token(Token = "0x40019DE")]
+		public CharSet CharSet;
+
+		/// <summary>Indicates whether the callee calls the <see langword="SetLastError" /> Win32 API function before returning from the attributed method.</summary>
+		// Token: 0x040019DF RID: 6623
+		[FieldOffset(Offset = "0x24")]
+		[Token(Token = "0x40019DF")]
+		public bool SetLastError;
+
+		/// <summary>Controls whether the <see cref="F:System.Runtime.InteropServices.DllImportAttribute.CharSet" /> field causes the common language runtime to search an unmanaged DLL for entry-point names other than the one specified.</summary>
+		// Token: 0x040019E0 RID: 6624
+		[FieldOffset(Offset = "0x25")]
+		[Token(Token = "0x40019E0")]
+		public bool ExactSpelling;
+
+		/// <summary>Indicates whether unmanaged methods that have <see langword="HRESULT" /> or <see langword="retval" /> return values are directly translated or whether <see langword="HRESULT" /> or <see langword="retval" /> return values are automatically converted to exceptions.</summary>
+		// Token: 0x040019E1 RID: 6625
+		[FieldOffset(Offset = "0x26")]
+		[Token(Token = "0x40019E1")]
+		public bool PreserveSig;
+
+		/// <summary>Indicates the calling convention of an entry point.</summary>
+		// Token: 0x040019E2 RID: 6626
+		[FieldOffset(Offset = "0x28")]
+		[Token(Token = "0x40019E2")]
+		public CallingConvention CallingConvention;
+
+		/// <summary>Enables or disables best-fit mapping behavior when converting Unicode characters to ANSI characters.</summary>
+		// Token: 0x040019E3 RID: 6627
+		[FieldOffset(Offset = "0x2C")]
+		[Token(Token = "0x40019E3")]
+		public bool BestFitMapping;
+
+		/// <summary>Enables or disables the throwing of an exception on an unmappable Unicode character that is converted to an ANSI "?" character.</summary>
+		// Token: 0x040019E4 RID: 6628
+		[FieldOffset(Offset = "0x2D")]
+		[Token(Token = "0x40019E4")]
+		public bool ThrowOnUnmappableChar;
+	}
+}

mscorlib/System/Runtime/InteropServices/DllImportSearchPath.cs

@@ -0,0 +1,41 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Specifies the paths that are used to search for DLLs that provide functions for platform invokes.</summary>
+	// Token: 0x02000594 RID: 1428
+	[Token(Token = "0x2000594")]
+	[Flags]
+	public enum DllImportSearchPath
+	{
+		/// <summary>Search for the dependencies of a DLL in the folder where the DLL is located before searching other folders.</summary>
+		// Token: 0x040019D4 RID: 6612
+		[Token(Token = "0x40019D4")]
+		UseDllDirectoryForDependencies = 256,
+		/// <summary>Include the application directory in the DLL search path.</summary>
+		// Token: 0x040019D5 RID: 6613
+		[Token(Token = "0x40019D5")]
+		ApplicationDirectory = 512,
+		/// <summary>Include any path that was explicitly added to the process-wide search path by using the Win32 AddDllDirectory function.</summary>
+		// Token: 0x040019D6 RID: 6614
+		[Token(Token = "0x40019D6")]
+		UserDirectories = 1024,
+		/// <summary>Include the <see langword="%WinDir%\System32" /> directory in the DLL search path.</summary>
+		// Token: 0x040019D7 RID: 6615
+		[Token(Token = "0x40019D7")]
+		System32 = 2048,
+		/// <summary>Include the application directory, the <see langword="%WinDir%\System32" /> directory, and user directories in the DLL search path.</summary>
+		// Token: 0x040019D8 RID: 6616
+		[Token(Token = "0x40019D8")]
+		SafeDirectories = 4096,
+		/// <summary>When searching for assembly dependencies, include the directory that contains the assembly itself, and search that directory first. This value is used by the .NET Framework, before the paths are passed to the Win32 LoadLibraryEx function.</summary>
+		// Token: 0x040019D9 RID: 6617
+		[Token(Token = "0x40019D9")]
+		AssemblyDirectory = 2,
+		/// <summary>Search the application directory, and then call the Win32 LoadLibraryEx function with the LOAD_WITH_ALTERED_SEARCH_PATH flag. This value is ignored if any other value is specified. Operating systems that do not support the <see cref="T:System.Runtime.InteropServices.DefaultDllImportSearchPathsAttribute" /> attribute use this value, and ignore other values.</summary>
+		// Token: 0x040019DA RID: 6618
+		[Token(Token = "0x40019DA")]
+		LegacyBehavior = 0
+	}
+}

mscorlib/System/Runtime/InteropServices/ErrorWrapper.cs

@@ -0,0 +1,18 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Wraps objects the marshaler should marshal as a <see langword="VT_ERROR" />.</summary>
+	// Token: 0x0200059C RID: 1436
+	[Token(Token = "0x200059C")]
+	[ComVisible(true)]
+	[Serializable]
+	public sealed class ErrorWrapper
+	{
+		// Token: 0x040019F5 RID: 6645
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x40019F5")]
+		private int m_ErrorCode;
+	}
+}

mscorlib/System/Runtime/InteropServices/ExternalException.cs

@@ -0,0 +1,88 @@
+using System;
+using System.Runtime.Serialization;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>The base exception type for all COM interop exceptions and structured exception handling (SEH) exceptions.</summary>
+	// Token: 0x0200059D RID: 1437
+	[Token(Token = "0x200059D")]
+	[ComVisible(true)]
+	[Serializable]
+	public class ExternalException : SystemException
+	{
+		/// <summary>Initializes a new instance of the <see langword="ExternalException" /> class with default properties.</summary>
+		// Token: 0x06002CC2 RID: 11458 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CC2")]
+		[Address(RVA = "0x2CEE010", Offset = "0x2CED010", VA = "0x182CEE010")]
+		public ExternalException()
+		{
+		}
+
+		/// <summary>Initializes a new instance of the <see langword="ExternalException" /> class with a specified error message.</summary>
+		/// <param name="message">The error message that specifies the reason for the exception.</param>
+		// Token: 0x06002CC3 RID: 11459 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CC3")]
+		[Address(RVA = "0x2CEE0A0", Offset = "0x2CED0A0", VA = "0x182CEE0A0")]
+		public ExternalException(string message)
+		{
+		}
+
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.InteropServices.ExternalException" /> class with a specified error message and a reference to the inner exception that is the cause of this exception.</summary>
+		/// <param name="message">The error message that explains the reason for the exception.</param>
+		/// <param name="inner">The exception that is the cause of the current exception. If the <paramref name="inner" /> parameter is not <see langword="null" />, the current exception is raised in a <see langword="catch" /> block that handles the inner exception.</param>
+		// Token: 0x06002CC4 RID: 11460 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CC4")]
+		[Address(RVA = "0x2CEE070", Offset = "0x2CED070", VA = "0x182CEE070")]
+		public ExternalException(string message, Exception inner)
+		{
+		}
+
+		/// <summary>Initializes a new instance of the <see langword="ExternalException" /> class with a specified error message and the HRESULT of the error.</summary>
+		/// <param name="message">The error message that specifies the reason for the exception.</param>
+		/// <param name="errorCode">The HRESULT of the error.</param>
+		// Token: 0x06002CC5 RID: 11461 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CC5")]
+		[Address(RVA = "0xCBE600", Offset = "0xCBD600", VA = "0x180CBE600")]
+		public ExternalException(string message, int errorCode)
+		{
+		}
+
+		/// <summary>Initializes a new instance of the <see langword="ExternalException" /> class from serialization data.</summary>
+		/// <param name="info">The object that holds the serialized object data.</param>
+		/// <param name="context">The contextual information about the source or destination.</param>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="info" /> is <see langword="null" />.</exception>
+		// Token: 0x06002CC6 RID: 11462 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CC6")]
+		[Address(RVA = "0x7241B0", Offset = "0x7231B0", VA = "0x1807241B0")]
+		protected ExternalException(SerializationInfo info, StreamingContext context)
+		{
+		}
+
+		/// <summary>Gets the <see langword="HRESULT" /> of the error.</summary>
+		/// <returns>The <see langword="HRESULT" /> of the error.</returns>
+		// Token: 0x170006C9 RID: 1737
+		// (get) Token: 0x06002CC7 RID: 11463 RVA: 0x00018E10 File Offset: 0x00017010
+		[Token(Token = "0x170006C9")]
+		public virtual int ErrorCode
+		{
+			[Token(Token = "0x6002CC7")]
+			[Address(RVA = "0x66A4F0", Offset = "0x6694F0", VA = "0x18066A4F0", Slot = "12")]
+			get
+			{
+				return 0;
+			}
+		}
+
+		/// <summary>Returns a string that contains the HRESULT of the error.</summary>
+		/// <returns>A string that represents the HRESULT.</returns>
+		// Token: 0x06002CC8 RID: 11464 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002CC8")]
+		[Address(RVA = "0x2CEDE70", Offset = "0x2CECE70", VA = "0x182CEDE70", Slot = "3")]
+		public override string ToString()
+		{
+			return null;
+		}
+	}
+}

mscorlib/System/Runtime/InteropServices/FieldOffsetAttribute.cs

@@ -0,0 +1,27 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Indicates the physical position of fields within the unmanaged representation of a class or structure.</summary>
+	// Token: 0x02000597 RID: 1431
+	[Token(Token = "0x2000597")]
+	[AttributeUsage(AttributeTargets.Field)]
+	[ComVisible(true)]
+	public sealed class FieldOffsetAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.InteropServices.FieldOffsetAttribute" /> class with the offset in the structure to the beginning of the field.</summary>
+		/// <param name="offset">The offset in bytes from the beginning of the structure to the beginning of the field.</param>
+		// Token: 0x06002CBC RID: 11452 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CBC")]
+		[Address(RVA = "0x41F8E0", Offset = "0x41E8E0", VA = "0x18041F8E0")]
+		public FieldOffsetAttribute(int offset)
+		{
+		}
+
+		// Token: 0x040019E5 RID: 6629
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x40019E5")]
+		internal int _val;
+	}
+}

mscorlib/System/Runtime/InteropServices/GCHandle.cs

@@ -0,0 +1,242 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Provides a way to access a managed object from unmanaged memory.</summary>
+	// Token: 0x020005A5 RID: 1445
+	[Token(Token = "0x20005A5")]
+	[MonoTODO]
+	[ComVisible(true)]
+	[MonoTODO("Struct should be [StructLayout(LayoutKind.Sequential)] but will need to be reordered for that.")]
+	public struct GCHandle
+	{
+		// Token: 0x06002CE9 RID: 11497 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CE9")]
+		[Address(RVA = "0x2CEE460", Offset = "0x2CED460", VA = "0x182CEE460")]
+		private GCHandle(IntPtr h)
+		{
+		}
+
+		// Token: 0x06002CEA RID: 11498 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CEA")]
+		[Address(RVA = "0x2CEE400", Offset = "0x2CED400", VA = "0x182CEE400")]
+		private GCHandle(object obj)
+		{
+		}
+
+		// Token: 0x06002CEB RID: 11499 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CEB")]
+		[Address(RVA = "0x2CEE430", Offset = "0x2CED430", VA = "0x182CEE430")]
+		internal GCHandle(object value, GCHandleType type)
+		{
+		}
+
+		/// <summary>Gets a value indicating whether the handle is allocated.</summary>
+		/// <returns>
+		///   <see langword="true" /> if the handle is allocated; otherwise, <see langword="false" />.</returns>
+		// Token: 0x170006CD RID: 1741
+		// (get) Token: 0x06002CEC RID: 11500 RVA: 0x00018E70 File Offset: 0x00017070
+		[Token(Token = "0x170006CD")]
+		public bool IsAllocated
+		{
+			[Token(Token = "0x6002CEC")]
+			[Address(RVA = "0x14E4320", Offset = "0x14E3320", VA = "0x1814E4320")]
+			get
+			{
+				return default(bool);
+			}
+		}
+
+		/// <summary>Gets or sets the object this handle represents.</summary>
+		/// <returns>The object this handle represents.</returns>
+		/// <exception cref="T:System.InvalidOperationException">The handle was freed, or never initialized.</exception>
+		// Token: 0x170006CE RID: 1742
+		// (get) Token: 0x06002CED RID: 11501 RVA: 0x00002082 File Offset: 0x00000282
+		// (set) Token: 0x06002CEE RID: 11502 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x170006CE")]
+		public object Target
+		{
+			[Token(Token = "0x6002CED")]
+			[Address(RVA = "0x2CEE480", Offset = "0x2CED480", VA = "0x182CEE480")]
+			get
+			{
+				return null;
+			}
+			[Token(Token = "0x6002CEE")]
+			[Address(RVA = "0x2CEE500", Offset = "0x2CED500", VA = "0x182CEE500")]
+			set
+			{
+			}
+		}
+
+		/// <summary>Retrieves the address of an object in a <see cref="F:System.Runtime.InteropServices.GCHandleType.Pinned" /> handle.</summary>
+		/// <returns>The address of the pinned object as an <see cref="T:System.IntPtr" />.</returns>
+		/// <exception cref="T:System.InvalidOperationException">The handle is any type other than <see cref="F:System.Runtime.InteropServices.GCHandleType.Pinned" />.</exception>
+		// Token: 0x06002CEF RID: 11503 RVA: 0x00018E88 File Offset: 0x00017088
+		[Token(Token = "0x6002CEF")]
+		[Address(RVA = "0x2CEE0D0", Offset = "0x2CED0D0", VA = "0x182CEE0D0")]
+		public IntPtr AddrOfPinnedObject()
+		{
+			return 0;
+		}
+
+		/// <summary>Allocates a <see cref="F:System.Runtime.InteropServices.GCHandleType.Normal" /> handle for the specified object.</summary>
+		/// <param name="value">The object that uses the <see cref="T:System.Runtime.InteropServices.GCHandle" />.</param>
+		/// <returns>A new <see cref="T:System.Runtime.InteropServices.GCHandle" /> that protects the object from garbage collection. This <see cref="T:System.Runtime.InteropServices.GCHandle" /> must be released with <see cref="M:System.Runtime.InteropServices.GCHandle.Free" /> when it is no longer needed.</returns>
+		/// <exception cref="T:System.ArgumentException">An instance with nonprimitive (non-blittable) members cannot be pinned.</exception>
+		// Token: 0x06002CF0 RID: 11504 RVA: 0x00018EA0 File Offset: 0x000170A0
+		[Token(Token = "0x6002CF0")]
+		[Address(RVA = "0x2CEE1D0", Offset = "0x2CED1D0", VA = "0x182CEE1D0")]
+		public static GCHandle Alloc(object value)
+		{
+			return default(GCHandle);
+		}
+
+		/// <summary>Allocates a handle of the specified type for the specified object.</summary>
+		/// <param name="value">The object that uses the <see cref="T:System.Runtime.InteropServices.GCHandle" />.</param>
+		/// <param name="type">One of the <see cref="T:System.Runtime.InteropServices.GCHandleType" /> values, indicating the type of <see cref="T:System.Runtime.InteropServices.GCHandle" /> to create.</param>
+		/// <returns>A new <see cref="T:System.Runtime.InteropServices.GCHandle" /> of the specified type. This <see cref="T:System.Runtime.InteropServices.GCHandle" /> must be released with <see cref="M:System.Runtime.InteropServices.GCHandle.Free" /> when it is no longer needed.</returns>
+		/// <exception cref="T:System.ArgumentException">An instance with nonprimitive (non-blittable) members cannot be pinned.</exception>
+		// Token: 0x06002CF1 RID: 11505 RVA: 0x00018EB8 File Offset: 0x000170B8
+		[Token(Token = "0x6002CF1")]
+		[Address(RVA = "0x2CEE1B0", Offset = "0x2CED1B0", VA = "0x182CEE1B0")]
+		public static GCHandle Alloc(object value, GCHandleType type)
+		{
+			return default(GCHandle);
+		}
+
+		/// <summary>Releases a <see cref="T:System.Runtime.InteropServices.GCHandle" />.</summary>
+		/// <exception cref="T:System.InvalidOperationException">The handle was freed or never initialized.</exception>
+		// Token: 0x06002CF2 RID: 11506 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CF2")]
+		[Address(RVA = "0x2CEE270", Offset = "0x2CED270", VA = "0x182CEE270")]
+		public void Free()
+		{
+		}
+
+		/// <summary>A <see cref="T:System.Runtime.InteropServices.GCHandle" /> is stored using an internal integer representation.</summary>
+		/// <param name="value">The <see cref="T:System.Runtime.InteropServices.GCHandle" /> for which the integer is required.</param>
+		/// <returns>The integer value.</returns>
+		// Token: 0x06002CF3 RID: 11507 RVA: 0x00018ED0 File Offset: 0x000170D0
+		[Token(Token = "0x6002CF3")]
+		[Address(RVA = "0x2CEE3F0", Offset = "0x2CED3F0", VA = "0x182CEE3F0")]
+		public static explicit operator IntPtr(GCHandle value)
+		{
+			return 0;
+		}
+
+		/// <summary>A <see cref="T:System.Runtime.InteropServices.GCHandle" /> is stored using an internal integer representation.</summary>
+		/// <param name="value">An <see cref="T:System.IntPtr" /> that indicates the handle for which the conversion is required.</param>
+		/// <returns>The stored <see cref="T:System.Runtime.InteropServices.GCHandle" /> object using an internal integer representation.</returns>
+		// Token: 0x06002CF4 RID: 11508 RVA: 0x00018EE8 File Offset: 0x000170E8
+		[Token(Token = "0x6002CF4")]
+		[Address(RVA = "0x2CEE300", Offset = "0x2CED300", VA = "0x182CEE300")]
+		public static explicit operator GCHandle(IntPtr value)
+		{
+			return default(GCHandle);
+		}
+
+		// Token: 0x06002CF5 RID: 11509 RVA: 0x00018F00 File Offset: 0x00017100
+		[Token(Token = "0x6002CF5")]
+		[Address(RVA = "0xAE5C70", Offset = "0xAE4C70", VA = "0x180AE5C70")]
+		private static bool CheckCurrentDomain(int handle)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x06002CF6 RID: 11510 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002CF6")]
+		[Address(RVA = "0x2CEE3E0", Offset = "0x2CED3E0", VA = "0x182CEE3E0")]
+		private static object GetTarget(int handle)
+		{
+			return null;
+		}
+
+		// Token: 0x06002CF7 RID: 11511 RVA: 0x00018F18 File Offset: 0x00017118
+		[Token(Token = "0x6002CF7")]
+		[Address(RVA = "0x2CEE3D0", Offset = "0x2CED3D0", VA = "0x182CEE3D0")]
+		private static int GetTargetHandle(object obj, int handle, GCHandleType type)
+		{
+			return 0;
+		}
+
+		// Token: 0x06002CF8 RID: 11512 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CF8")]
+		[Address(RVA = "0x2CEE260", Offset = "0x2CED260", VA = "0x182CEE260")]
+		private static void FreeHandle(int handle)
+		{
+		}
+
+		// Token: 0x06002CF9 RID: 11513 RVA: 0x00018F30 File Offset: 0x00017130
+		[Token(Token = "0x6002CF9")]
+		[Address(RVA = "0x2CEE3C0", Offset = "0x2CED3C0", VA = "0x182CEE3C0")]
+		private static IntPtr GetAddrOfPinnedObject(int handle)
+		{
+			return 0;
+		}
+
+		/// <summary>Returns a value indicating whether two <see cref="T:System.Runtime.InteropServices.GCHandle" /> objects are equal.</summary>
+		/// <param name="a">A <see cref="T:System.Runtime.InteropServices.GCHandle" /> object to compare with the <paramref name="b" /> parameter.</param>
+		/// <param name="b">A <see cref="T:System.Runtime.InteropServices.GCHandle" /> object to compare with the <paramref name="a" /> parameter.</param>
+		/// <returns>
+		///   <see langword="true" /> if the <paramref name="a" /> and <paramref name="b" /> parameters are equal; otherwise, <see langword="false" />.</returns>
+		// Token: 0x06002CFA RID: 11514 RVA: 0x00018F48 File Offset: 0x00017148
+		[Token(Token = "0x6002CFA")]
+		[Address(RVA = "0x593050", Offset = "0x592050", VA = "0x180593050")]
+		public static bool operator ==(GCHandle a, GCHandle b)
+		{
+			return default(bool);
+		}
+
+		/// <summary>Determines whether the specified <see cref="T:System.Runtime.InteropServices.GCHandle" /> object is equal to the current <see cref="T:System.Runtime.InteropServices.GCHandle" /> object.</summary>
+		/// <param name="o">The <see cref="T:System.Runtime.InteropServices.GCHandle" /> object to compare with the current <see cref="T:System.Runtime.InteropServices.GCHandle" /> object.</param>
+		/// <returns>
+		///   <see langword="true" /> if the specified <see cref="T:System.Runtime.InteropServices.GCHandle" /> object is equal to the current <see cref="T:System.Runtime.InteropServices.GCHandle" /> object; otherwise, <see langword="false" />.</returns>
+		// Token: 0x06002CFB RID: 11515 RVA: 0x00018F60 File Offset: 0x00017160
+		[Token(Token = "0x6002CFB")]
+		[Address(RVA = "0x2CEE1E0", Offset = "0x2CED1E0", VA = "0x182CEE1E0", Slot = "0")]
+		public override bool Equals(object o)
+		{
+			return default(bool);
+		}
+
+		/// <summary>Returns an identifier for the current <see cref="T:System.Runtime.InteropServices.GCHandle" /> object.</summary>
+		/// <returns>An identifier for the current <see cref="T:System.Runtime.InteropServices.GCHandle" /> object.</returns>
+		// Token: 0x06002CFC RID: 11516 RVA: 0x00018F78 File Offset: 0x00017178
+		[Token(Token = "0x6002CFC")]
+		[Address(RVA = "0x592FE0", Offset = "0x591FE0", VA = "0x180592FE0", Slot = "2")]
+		public override int GetHashCode()
+		{
+			return 0;
+		}
+
+		/// <summary>Returns a new <see cref="T:System.Runtime.InteropServices.GCHandle" /> object created from a handle to a managed object.</summary>
+		/// <param name="value">An <see cref="T:System.IntPtr" /> handle to a managed object to create a <see cref="T:System.Runtime.InteropServices.GCHandle" /> object from.</param>
+		/// <returns>A new <see cref="T:System.Runtime.InteropServices.GCHandle" /> object that corresponds to the value parameter.</returns>
+		/// <exception cref="T:System.InvalidOperationException">The value of the <paramref name="value" /> parameter is <see cref="F:System.IntPtr.Zero" />.</exception>
+		// Token: 0x06002CFD RID: 11517 RVA: 0x00018F90 File Offset: 0x00017190
+		[Token(Token = "0x6002CFD")]
+		[Address(RVA = "0x2CEE300", Offset = "0x2CED300", VA = "0x182CEE300")]
+		public static GCHandle FromIntPtr(IntPtr value)
+		{
+			return default(GCHandle);
+		}
+
+		/// <summary>Returns the internal integer representation of a <see cref="T:System.Runtime.InteropServices.GCHandle" /> object.</summary>
+		/// <param name="value">A <see cref="T:System.Runtime.InteropServices.GCHandle" /> object to retrieve an internal integer representation from.</param>
+		/// <returns>An <see cref="T:System.IntPtr" /> object that represents a <see cref="T:System.Runtime.InteropServices.GCHandle" /> object.</returns>
+		// Token: 0x06002CFE RID: 11518 RVA: 0x00018FA8 File Offset: 0x000171A8
+		[Token(Token = "0x6002CFE")]
+		[Address(RVA = "0x2CEE3F0", Offset = "0x2CED3F0", VA = "0x182CEE3F0")]
+		public static IntPtr ToIntPtr(GCHandle value)
+		{
+			return 0;
+		}
+
+		// Token: 0x040019FE RID: 6654
+		[FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x40019FE")]
+		private int handle;
+	}
+}

mscorlib/System/Runtime/InteropServices/GCHandleType.cs

@@ -0,0 +1,30 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Represents the types of handles the <see cref="T:System.Runtime.InteropServices.GCHandle" /> class can allocate.</summary>
+	// Token: 0x020005A6 RID: 1446
+	[Token(Token = "0x20005A6")]
+	[ComVisible(true)]
+	[Serializable]
+	public enum GCHandleType
+	{
+		/// <summary>This handle type is used to track an object, but allow it to be collected. When an object is collected, the contents of the <see cref="T:System.Runtime.InteropServices.GCHandle" /> are zeroed. <see langword="Weak" /> references are zeroed before the finalizer runs, so even if the finalizer resurrects the object, the <see langword="Weak" /> reference is still zeroed.</summary>
+		// Token: 0x04001A00 RID: 6656
+		[Token(Token = "0x4001A00")]
+		Weak,
+		/// <summary>This handle type is similar to <see cref="F:System.Runtime.InteropServices.GCHandleType.Weak" />, but the handle is not zeroed if the object is resurrected during finalization.</summary>
+		// Token: 0x04001A01 RID: 6657
+		[Token(Token = "0x4001A01")]
+		WeakTrackResurrection,
+		/// <summary>This handle type represents an opaque handle, meaning you cannot resolve the address of the pinned object through the handle. You can use this type to track an object and prevent its collection by the garbage collector. This enumeration member is useful when an unmanaged client holds the only reference, which is undetectable from the garbage collector, to a managed object.</summary>
+		// Token: 0x04001A02 RID: 6658
+		[Token(Token = "0x4001A02")]
+		Normal,
+		/// <summary>This handle type is similar to <see cref="F:System.Runtime.InteropServices.GCHandleType.Normal" />, but allows the address of the pinned object to be taken. This prevents the garbage collector from moving the object and hence undermines the efficiency of the garbage collector. Use the <see cref="M:System.Runtime.InteropServices.GCHandle.Free" /> method to free the allocated handle as soon as possible.</summary>
+		// Token: 0x04001A03 RID: 6659
+		[Token(Token = "0x4001A03")]
+		Pinned
+	}
+}

mscorlib/System/Runtime/InteropServices/GuidAttribute.cs

@@ -0,0 +1,42 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Supplies an explicit <see cref="T:System.Guid" /> when an automatic GUID is undesirable.</summary>
+	// Token: 0x0200058F RID: 1423
+	[Token(Token = "0x200058F")]
+	[ComVisible(true)]
+	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Interface | AttributeTargets.Delegate)]
+	public sealed class GuidAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.InteropServices.GuidAttribute" /> class with the specified GUID.</summary>
+		/// <param name="guid">The <see cref="T:System.Guid" /> to be assigned.</param>
+		// Token: 0x06002CB0 RID: 11440 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CB0")]
+		[Address(RVA = "0x681CA0", Offset = "0x680CA0", VA = "0x180681CA0")]
+		public GuidAttribute(string guid)
+		{
+		}
+
+		/// <summary>Gets the <see cref="T:System.Guid" /> of the class.</summary>
+		/// <returns>The <see cref="T:System.Guid" /> of the class.</returns>
+		// Token: 0x170006C7 RID: 1735
+		// (get) Token: 0x06002CB1 RID: 11441 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x170006C7")]
+		public string Value
+		{
+			[Token(Token = "0x6002CB1")]
+			[Address(RVA = "0x411530", Offset = "0x410530", VA = "0x180411530")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x040019D2 RID: 6610
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x40019D2")]
+		internal string _val;
+	}
+}

mscorlib/System/Runtime/InteropServices/HandleRef.cs

@@ -0,0 +1,47 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Wraps a managed object holding a handle to a resource that is passed to unmanaged code using platform invoke.</summary>
+	// Token: 0x0200059E RID: 1438
+	[Token(Token = "0x200059E")]
+	[ComVisible(true)]
+	public struct HandleRef
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.InteropServices.HandleRef" /> class with the object to wrap and a handle to the resource used by unmanaged code.</summary>
+		/// <param name="wrapper">A managed object that should not be finalized until the platform invoke call returns.</param>
+		/// <param name="handle">An <see cref="T:System.IntPtr" /> that indicates a handle to a resource.</param>
+		// Token: 0x06002CC9 RID: 11465 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CC9")]
+		[Address(RVA = "0x4AF6A0", Offset = "0x4AE6A0", VA = "0x1804AF6A0")]
+		public HandleRef(object wrapper, IntPtr handle)
+		{
+		}
+
+		/// <summary>Gets the handle to a resource.</summary>
+		/// <returns>The handle to a resource.</returns>
+		// Token: 0x170006CA RID: 1738
+		// (get) Token: 0x06002CCA RID: 11466 RVA: 0x00018E28 File Offset: 0x00017028
+		[Token(Token = "0x170006CA")]
+		public IntPtr Handle
+		{
+			[Token(Token = "0x6002CCA")]
+			[Address(RVA = "0x634760", Offset = "0x633760", VA = "0x180634760")]
+			get
+			{
+				return 0;
+			}
+		}
+
+		// Token: 0x040019F6 RID: 6646
+		[FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x40019F6")]
+		internal object m_wrapper;
+
+		// Token: 0x040019F7 RID: 6647
+		[FieldOffset(Offset = "0x8")]
+		[Token(Token = "0x40019F7")]
+		internal IntPtr m_handle;
+	}
+}

mscorlib/System/Runtime/InteropServices/ICustomMarshaler.cs

@@ -0,0 +1,49 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Provides custom wrappers for handling method calls.</summary>
+	// Token: 0x0200059F RID: 1439
+	[Token(Token = "0x200059F")]
+	[ComVisible(true)]
+	public interface ICustomMarshaler
+	{
+		/// <summary>Converts the unmanaged data to managed data.</summary>
+		/// <param name="pNativeData">A pointer to the unmanaged data to be wrapped.</param>
+		/// <returns>An object that represents the managed view of the COM data.</returns>
+		// Token: 0x06002CCB RID: 11467
+		[Token(Token = "0x6002CCB")]
+		[Address(Slot = "0")]
+		object MarshalNativeToManaged(IntPtr pNativeData);
+
+		/// <summary>Converts the managed data to unmanaged data.</summary>
+		/// <param name="ManagedObj">The managed object to be converted.</param>
+		/// <returns>A pointer to the COM view of the managed object.</returns>
+		// Token: 0x06002CCC RID: 11468
+		[Token(Token = "0x6002CCC")]
+		[Address(Slot = "1")]
+		IntPtr MarshalManagedToNative(object ManagedObj);
+
+		/// <summary>Performs necessary cleanup of the unmanaged data when it is no longer needed.</summary>
+		/// <param name="pNativeData">A pointer to the unmanaged data to be destroyed.</param>
+		// Token: 0x06002CCD RID: 11469
+		[Token(Token = "0x6002CCD")]
+		[Address(Slot = "2")]
+		void CleanUpNativeData(IntPtr pNativeData);
+
+		/// <summary>Performs necessary cleanup of the managed data when it is no longer needed.</summary>
+		/// <param name="ManagedObj">The managed object to be destroyed.</param>
+		// Token: 0x06002CCE RID: 11470
+		[Token(Token = "0x6002CCE")]
+		[Address(Slot = "3")]
+		void CleanUpManagedData(object ManagedObj);
+
+		/// <summary>Returns the size of the native data to be marshaled.</summary>
+		/// <returns>The size, in bytes, of the native data.</returns>
+		// Token: 0x06002CCF RID: 11471
+		[Token(Token = "0x6002CCF")]
+		[Address(Slot = "4")]
+		int GetNativeDataSize();
+	}
+}

mscorlib/System/Runtime/InteropServices/InAttribute.cs

@@ -0,0 +1,21 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Indicates that data should be marshaled from the caller to the callee, but not back to the caller.</summary>
+	// Token: 0x02000591 RID: 1425
+	[Token(Token = "0x2000591")]
+	[ComVisible(true)]
+	[AttributeUsage(AttributeTargets.Parameter)]
+	public sealed class InAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.InteropServices.InAttribute" /> class.</summary>
+		// Token: 0x06002CB3 RID: 11443 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CB3")]
+		[Address(RVA = "0x42BA20", Offset = "0x42AA20", VA = "0x18042BA20")]
+		public InAttribute()
+		{
+		}
+	}
+}

mscorlib/System/Runtime/InteropServices/InterfaceTypeAttribute.cs

@@ -0,0 +1,27 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Indicates whether a managed interface is dual, dispatch-only, or <see langword="IUnknown" /> -only when exposed to COM.</summary>
+	// Token: 0x02000587 RID: 1415
+	[Token(Token = "0x2000587")]
+	[ComVisible(true)]
+	[AttributeUsage(AttributeTargets.Interface)]
+	public sealed class InterfaceTypeAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.InteropServices.InterfaceTypeAttribute" /> class with the specified <see cref="T:System.Runtime.InteropServices.ComInterfaceType" /> enumeration member.</summary>
+		/// <param name="interfaceType">One of the <see cref="T:System.Runtime.InteropServices.ComInterfaceType" /> values that describes how the interface should be exposed to COM clients.</param>
+		// Token: 0x06002CAB RID: 11435 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CAB")]
+		[Address(RVA = "0x41F8E0", Offset = "0x41E8E0", VA = "0x18041F8E0")]
+		public InterfaceTypeAttribute(ComInterfaceType interfaceType)
+		{
+		}
+
+		// Token: 0x04001976 RID: 6518
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x4001976")]
+		internal ComInterfaceType _val;
+	}
+}

mscorlib/System/Runtime/InteropServices/InvalidComObjectException.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Runtime.Serialization;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>The exception thrown when an invalid COM object is used.</summary>
+	// Token: 0x020005A0 RID: 1440
+	[Token(Token = "0x20005A0")]
+	[ComVisible(true)]
+	[Serializable]
+	public class InvalidComObjectException : SystemException
+	{
+		/// <summary>Initializes an instance of the <see langword="InvalidComObjectException" /> with default properties.</summary>
+		// Token: 0x06002CD0 RID: 11472 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CD0")]
+		[Address(RVA = "0x2CEEAE0", Offset = "0x2CEDAE0", VA = "0x182CEEAE0")]
+		public InvalidComObjectException()
+		{
+		}
+
+		/// <summary>Initializes a new instance of the <see langword="COMException" /> class from serialization data.</summary>
+		/// <param name="info">The object that holds the serialized object data.</param>
+		/// <param name="context">The contextual information about the source or destination.</param>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="info" /> is <see langword="null" />.</exception>
+		// Token: 0x06002CD1 RID: 11473 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CD1")]
+		[Address(RVA = "0x7241B0", Offset = "0x7231B0", VA = "0x1807241B0")]
+		protected InvalidComObjectException(SerializationInfo info, StreamingContext context)
+		{
+		}
+	}
+}

mscorlib/System/Runtime/InteropServices/InvalidOleVariantTypeException.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Runtime.Serialization;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>The exception thrown by the marshaler when it encounters an argument of a variant type that can not be marshaled to managed code.</summary>
+	// Token: 0x020005A1 RID: 1441
+	[Token(Token = "0x20005A1")]
+	[ComVisible(true)]
+	[Serializable]
+	public class InvalidOleVariantTypeException : SystemException
+	{
+		/// <summary>Initializes a new instance of the <see langword="InvalidOleVariantTypeException" /> class with default values.</summary>
+		// Token: 0x06002CD2 RID: 11474 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CD2")]
+		[Address(RVA = "0x2CEEB40", Offset = "0x2CEDB40", VA = "0x182CEEB40")]
+		public InvalidOleVariantTypeException()
+		{
+		}
+
+		/// <summary>Initializes a new instance of the <see langword="InvalidOleVariantTypeException" /> class from serialization data.</summary>
+		/// <param name="info">The object that holds the serialized object data.</param>
+		/// <param name="context">The contextual information about the source or destination.</param>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="info" /> is <see langword="null" />.</exception>
+		// Token: 0x06002CD3 RID: 11475 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CD3")]
+		[Address(RVA = "0x7241B0", Offset = "0x7231B0", VA = "0x1807241B0")]
+		protected InvalidOleVariantTypeException(SerializationInfo info, StreamingContext context)
+		{
+		}
+	}
+}

mscorlib/System/Runtime/InteropServices/Marshal.cs

@@ -0,0 +1,949 @@
+using System;
+using System.Runtime.ConstrainedExecution;
+using System.Security;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Provides a collection of methods for allocating unmanaged memory, copying unmanaged memory blocks, and converting managed to unmanaged types, as well as other miscellaneous methods used when interacting with unmanaged code.</summary>
+	// Token: 0x020005A7 RID: 1447
+	[Token(Token = "0x20005A7")]
+	public static class Marshal
+	{
+		// Token: 0x06002CFF RID: 11519 RVA: 0x00018FC0 File Offset: 0x000171C0
+		[Token(Token = "0x6002CFF")]
+		[Address(RVA = "0x2CF0FD0", Offset = "0x2CEFFD0", VA = "0x182CF0FD0")]
+		private static int AddRefInternal(IntPtr pUnk)
+		{
+			return 0;
+		}
+
+		/// <summary>Increments the reference count on the specified interface.</summary>
+		/// <param name="pUnk">The interface reference count to increment.</param>
+		/// <returns>The new value of the reference count on the <paramref name="pUnk" /> parameter.</returns>
+		// Token: 0x06002D00 RID: 11520 RVA: 0x00018FD8 File Offset: 0x000171D8
+		[Token(Token = "0x6002D00")]
+		[Address(RVA = "0x2CF0FE0", Offset = "0x2CEFFE0", VA = "0x182CF0FE0")]
+		public static int AddRef(IntPtr pUnk)
+		{
+			return 0;
+		}
+
+		/// <summary>Allocates a block of memory of specified size from the COM task memory allocator.</summary>
+		/// <param name="cb">The size of the block of memory to be allocated.</param>
+		/// <returns>An integer representing the address of the block of memory allocated. This memory must be released with <see cref="M:System.Runtime.InteropServices.Marshal.FreeCoTaskMem(System.IntPtr)" />.</returns>
+		/// <exception cref="T:System.OutOfMemoryException">There is insufficient memory to satisfy the request.</exception>
+		// Token: 0x06002D01 RID: 11521 RVA: 0x00018FF0 File Offset: 0x000171F0
+		[Token(Token = "0x6002D01")]
+		[Address(RVA = "0x2CF1080", Offset = "0x2CF0080", VA = "0x182CF1080")]
+		public static IntPtr AllocCoTaskMem(int cb)
+		{
+			return 0;
+		}
+
+		/// <summary>Allocates memory from the unmanaged memory of the process by using the pointer to the specified number of bytes.</summary>
+		/// <param name="cb">The required number of bytes in memory.</param>
+		/// <returns>A pointer to the newly allocated memory. This memory must be released using the <see cref="M:System.Runtime.InteropServices.Marshal.FreeHGlobal(System.IntPtr)" /> method.</returns>
+		/// <exception cref="T:System.OutOfMemoryException">There is insufficient memory to satisfy the request.</exception>
+		// Token: 0x06002D02 RID: 11522 RVA: 0x00019008 File Offset: 0x00017208
+		[Token(Token = "0x6002D02")]
+		[Address(RVA = "0x2CF1090", Offset = "0x2CF0090", VA = "0x182CF1090")]
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
+		public static IntPtr AllocHGlobal(IntPtr cb)
+		{
+			return 0;
+		}
+
+		/// <summary>Allocates memory from the unmanaged memory of the process by using the specified number of bytes.</summary>
+		/// <param name="cb">The required number of bytes in memory.</param>
+		/// <returns>A pointer to the newly allocated memory. This memory must be released using the <see cref="M:System.Runtime.InteropServices.Marshal.FreeHGlobal(System.IntPtr)" /> method.</returns>
+		/// <exception cref="T:System.OutOfMemoryException">There is insufficient memory to satisfy the request.</exception>
+		// Token: 0x06002D03 RID: 11523 RVA: 0x00019020 File Offset: 0x00017220
+		[Token(Token = "0x6002D03")]
+		[Address(RVA = "0x2CF10A0", Offset = "0x2CF00A0", VA = "0x182CF10A0")]
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
+		public static IntPtr AllocHGlobal(int cb)
+		{
+			return 0;
+		}
+
+		// Token: 0x06002D04 RID: 11524 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002D04")]
+		[Address(RVA = "0x2CF3880", Offset = "0x2CF2880", VA = "0x182CF3880")]
+		internal static void copy_to_unmanaged(Array source, int startIndex, IntPtr destination, int length)
+		{
+		}
+
+		// Token: 0x06002D05 RID: 11525 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002D05")]
+		[Address(RVA = "0x2CF3870", Offset = "0x2CF2870", VA = "0x182CF3870")]
+		internal static void copy_from_unmanaged(IntPtr source, int startIndex, Array destination, int length)
+		{
+		}
+
+		/// <summary>Copies data from a one-dimensional, managed 8-bit unsigned integer array to an unmanaged memory pointer.</summary>
+		/// <param name="source">The one-dimensional array to copy from.</param>
+		/// <param name="startIndex">The zero-based index in the source array where copying should start.</param>
+		/// <param name="destination">The memory pointer to copy to.</param>
+		/// <param name="length">The number of array elements to copy.</param>
+		/// <exception cref="T:System.ArgumentOutOfRangeException">
+		///   <paramref name="startIndex" /> and <paramref name="length" /> are not valid.</exception>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="source" />, <paramref name="startIndex" />, <paramref name="destination" />, or <paramref name="length" /> is <see langword="null" />.</exception>
+		// Token: 0x06002D06 RID: 11526 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002D06")]
+		[Address(RVA = "0x2CF1F90", Offset = "0x2CF0F90", VA = "0x182CF1F90")]
+		public static void Copy(byte[] source, int startIndex, IntPtr destination, int length)
+		{
+		}
+
+		/// <summary>Copies data from a one-dimensional, managed <see cref="T:System.IntPtr" /> array to an unmanaged memory pointer.</summary>
+		/// <param name="source">The one-dimensional array to copy from.</param>
+		/// <param name="startIndex">The zero-based index in the source array where copying should start.</param>
+		/// <param name="destination">The memory pointer to copy to.</param>
+		/// <param name="length">The number of array elements to copy.</param>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="source" />, <paramref name="destination" />, <paramref name="startIndex" />, or <paramref name="length" /> is <see langword="null" />.</exception>
+		// Token: 0x06002D07 RID: 11527 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002D07")]
+		[Address(RVA = "0x2CF2190", Offset = "0x2CF1190", VA = "0x182CF2190")]
+		public static void Copy(IntPtr[] source, int startIndex, IntPtr destination, int length)
+		{
+		}
+
+		/// <summary>Copies data from an unmanaged memory pointer to a managed 8-bit unsigned integer array.</summary>
+		/// <param name="source">The memory pointer to copy from.</param>
+		/// <param name="destination">The array to copy to.</param>
+		/// <param name="startIndex">The zero-based index in the destination array where copying should start.</param>
+		/// <param name="length">The number of array elements to copy.</param>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="source" />, <paramref name="destination" />, <paramref name="startIndex" />, or <paramref name="length" /> is <see langword="null" />.</exception>
+		// Token: 0x06002D08 RID: 11528 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002D08")]
+		[Address(RVA = "0x2CF2110", Offset = "0x2CF1110", VA = "0x182CF2110")]
+		public static void Copy(IntPtr source, byte[] destination, int startIndex, int length)
+		{
+		}
+
+		/// <summary>Copies data from an unmanaged memory pointer to a managed character array.</summary>
+		/// <param name="source">The memory pointer to copy from.</param>
+		/// <param name="destination">The array to copy to.</param>
+		/// <param name="startIndex">The zero-based index in the destination array where copying should start.</param>
+		/// <param name="length">The number of array elements to copy.</param>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="source" />, <paramref name="destination" />, <paramref name="startIndex" />, or <paramref name="length" /> is <see langword="null" />.</exception>
+		// Token: 0x06002D09 RID: 11529 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002D09")]
+		[Address(RVA = "0x2CF2090", Offset = "0x2CF1090", VA = "0x182CF2090")]
+		public static void Copy(IntPtr source, char[] destination, int startIndex, int length)
+		{
+		}
+
+		/// <summary>Copies data from an unmanaged memory pointer to a managed 16-bit signed integer array.</summary>
+		/// <param name="source">The memory pointer to copy from.</param>
+		/// <param name="destination">The array to copy to.</param>
+		/// <param name="startIndex">The zero-based index in the destination array where copying should start.</param>
+		/// <param name="length">The number of array elements to copy.</param>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="source" />, <paramref name="destination" />, <paramref name="startIndex" />, or <paramref name="length" /> is <see langword="null" />.</exception>
+		// Token: 0x06002D0A RID: 11530 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002D0A")]
+		[Address(RVA = "0x2CF2210", Offset = "0x2CF1210", VA = "0x182CF2210")]
+		public static void Copy(IntPtr source, short[] destination, int startIndex, int length)
+		{
+		}
+
+		/// <summary>Copies data from an unmanaged memory pointer to a managed single-precision floating-point number array.</summary>
+		/// <param name="source">The memory pointer to copy from.</param>
+		/// <param name="destination">The array to copy to.</param>
+		/// <param name="startIndex">The zero-based index in the destination array where copying should start.</param>
+		/// <param name="length">The number of array elements to copy.</param>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="source" />, <paramref name="destination" />, <paramref name="startIndex" />, or <paramref name="length" /> is <see langword="null" />.</exception>
+		// Token: 0x06002D0B RID: 11531 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002D0B")]
+		[Address(RVA = "0x2CF2010", Offset = "0x2CF1010", VA = "0x182CF2010")]
+		public static void Copy(IntPtr source, float[] destination, int startIndex, int length)
+		{
+		}
+
+		/// <summary>Frees all substructures that the specified unmanaged memory block points to.</summary>
+		/// <param name="ptr">A pointer to an unmanaged block of memory.</param>
+		/// <param name="structuretype">Type of a formatted class. This provides the layout information necessary to delete the buffer in the <paramref name="ptr" /> parameter.</param>
+		/// <exception cref="T:System.ArgumentException">
+		///   <paramref name="structureType" /> has an automatic layout. Use sequential or explicit instead.</exception>
+		// Token: 0x06002D0C RID: 11532 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002D0C")]
+		[Address(RVA = "0x2CF2290", Offset = "0x2CF1290", VA = "0x182CF2290")]
+		[ComVisible(true)]
+		public static void DestroyStructure(IntPtr ptr, Type structuretype)
+		{
+		}
+
+		/// <summary>Frees a <see langword="BSTR" /> using the COM SysFreeString function.</summary>
+		/// <param name="ptr">The address of the BSTR to be freed.</param>
+		// Token: 0x06002D0D RID: 11533 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002D0D")]
+		[Address(RVA = "0x2CF22A0", Offset = "0x2CF12A0", VA = "0x182CF22A0")]
+		public static void FreeBSTR(IntPtr ptr)
+		{
+		}
+
+		/// <summary>Frees a block of memory allocated by the unmanaged COM task memory allocator.</summary>
+		/// <param name="ptr">The address of the memory to be freed.</param>
+		// Token: 0x06002D0E RID: 11534 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002D0E")]
+		[Address(RVA = "0x2CF22B0", Offset = "0x2CF12B0", VA = "0x182CF22B0")]
+		public static void FreeCoTaskMem(IntPtr ptr)
+		{
+		}
+
+		/// <summary>Frees memory previously allocated from the unmanaged memory of the process.</summary>
+		/// <param name="hglobal">The handle returned by the original matching call to <see cref="M:System.Runtime.InteropServices.Marshal.AllocHGlobal(System.IntPtr)" />.</param>
+		// Token: 0x06002D0F RID: 11535 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002D0F")]
+		[Address(RVA = "0x2CF22C0", Offset = "0x2CF12C0", VA = "0x182CF22C0")]
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
+		public static void FreeHGlobal(IntPtr hglobal)
+		{
+		}
+
+		// Token: 0x06002D10 RID: 11536 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002D10")]
+		[Address(RVA = "0x2CF1100", Offset = "0x2CF0100", VA = "0x182CF1100")]
+		private static void ClearBSTR(IntPtr ptr)
+		{
+		}
+
+		/// <summary>Frees a BSTR pointer that was allocated using the <see cref="M:System.Runtime.InteropServices.Marshal.SecureStringToBSTR(System.Security.SecureString)" /> method.</summary>
+		/// <param name="s">The address of the <see langword="BSTR" /> to free.</param>
+		// Token: 0x06002D11 RID: 11537 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002D11")]
+		[Address(RVA = "0x2CF3580", Offset = "0x2CF2580", VA = "0x182CF3580")]
+		public static void ZeroFreeBSTR(IntPtr s)
+		{
+		}
+
+		// Token: 0x06002D12 RID: 11538 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002D12")]
+		[Address(RVA = "0x2CF11E0", Offset = "0x2CF01E0", VA = "0x182CF11E0")]
+		private static void ClearUnicode(IntPtr ptr)
+		{
+		}
+
+		/// <summary>Frees an unmanaged string pointer that was allocated using the <see cref="M:System.Runtime.InteropServices.Marshal.SecureStringToGlobalAllocUnicode(System.Security.SecureString)" /> method.</summary>
+		/// <param name="s">The address of the unmanaged string to free.</param>
+		// Token: 0x06002D13 RID: 11539 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002D13")]
+		[Address(RVA = "0x2CF36B0", Offset = "0x2CF26B0", VA = "0x182CF36B0")]
+		public static void ZeroFreeGlobalAllocUnicode(IntPtr s)
+		{
+		}
+
+		// Token: 0x06002D14 RID: 11540 RVA: 0x00019038 File Offset: 0x00017238
+		[Token(Token = "0x6002D14")]
+		[Address(RVA = "0x2CF22D0", Offset = "0x2CF12D0", VA = "0x182CF22D0")]
+		private static IntPtr GetCCW(object o, Type T)
+		{
+			return 0;
+		}
+
+		// Token: 0x06002D15 RID: 11541 RVA: 0x00019050 File Offset: 0x00017250
+		[Token(Token = "0x6002D15")]
+		[Address(RVA = "0x2CF22E0", Offset = "0x2CF12E0", VA = "0x182CF22E0")]
+		private static IntPtr GetComInterfaceForObjectInternal(object o, Type T)
+		{
+			return 0;
+		}
+
+		/// <summary>Returns a pointer to an IUnknown interface that represents the specified interface on the specified object. Custom query interface access is enabled by default.</summary>
+		/// <param name="o">The object that provides the interface.</param>
+		/// <param name="T">The type of interface that is requested.</param>
+		/// <returns>The interface pointer that represents the specified interface for the object.</returns>
+		/// <exception cref="T:System.ArgumentException">The <typeparamref name="T" /> parameter is not an interface.  
+		///  -or-  
+		///  The type is not visible to COM.  
+		///  -or-  
+		///  The <typeparamref name="T" /> parameter is a generic type definition.</exception>
+		/// <exception cref="T:System.InvalidCastException">The <paramref name="o" /> parameter does not support the requested interface.</exception>
+		/// <exception cref="T:System.ArgumentNullException">The <paramref name="o" /> parameter is <see langword="null" />.  
+		///  -or-  
+		///  The <typeparamref name="T" /> parameter is <see langword="null" />.</exception>
+		// Token: 0x06002D16 RID: 11542 RVA: 0x00019068 File Offset: 0x00017268
+		[Token(Token = "0x6002D16")]
+		[Address(RVA = "0x2CF2340", Offset = "0x2CF1340", VA = "0x182CF2340")]
+		public static IntPtr GetComInterfaceForObject(object o, Type T)
+		{
+			return 0;
+		}
+
+		/// <summary>Converts the specified exception to an HRESULT.</summary>
+		/// <param name="e">The exception to convert to an HRESULT.</param>
+		/// <returns>The HRESULT mapped to the supplied exception.</returns>
+		// Token: 0x06002D17 RID: 11543 RVA: 0x00019080 File Offset: 0x00017280
+		[Token(Token = "0x6002D17")]
+		[Address(RVA = "0x2CF27B0", Offset = "0x2CF17B0", VA = "0x182CF27B0")]
+		public static int GetHRForException(Exception e)
+		{
+			return 0;
+		}
+
+		/// <summary>Returns the error code returned by the last unmanaged function that was called using platform invoke that has the <see cref="F:System.Runtime.InteropServices.DllImportAttribute.SetLastError" /> flag set.</summary>
+		/// <returns>The last error code set by a call to the Win32 SetLastError function.</returns>
+		// Token: 0x06002D18 RID: 11544 RVA: 0x00019098 File Offset: 0x00017298
+		[Token(Token = "0x6002D18")]
+		[Address(RVA = "0x2CF27C0", Offset = "0x2CF17C0", VA = "0x182CF27C0")]
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
+		public static int GetLastWin32Error()
+		{
+			return 0;
+		}
+
+		/// <summary>Performs a pre-link check for all methods on a class.</summary>
+		/// <param name="c">The class whose methods are to be checked.</param>
+		/// <exception cref="T:System.ArgumentNullException">The <paramref name="c" /> parameter is <see langword="null" />.</exception>
+		// Token: 0x06002D19 RID: 11545 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002D19")]
+		[Address(RVA = "0x2CF27D0", Offset = "0x2CF17D0", VA = "0x182CF27D0")]
+		public static void PrelinkAll(Type c)
+		{
+		}
+
+		/// <summary>Copies all characters up to the first null character from an unmanaged ANSI string to a managed <see cref="T:System.String" />, and widens each ANSI character to Unicode.</summary>
+		/// <param name="ptr">The address of the first character of the unmanaged string.</param>
+		/// <returns>A managed string that holds a copy of the unmanaged ANSI string. If <paramref name="ptr" /> is <see langword="null" />, the method returns a null string.</returns>
+		// Token: 0x06002D1A RID: 11546 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002D1A")]
+		[Address(RVA = "0x2CF27F0", Offset = "0x2CF17F0", VA = "0x182CF27F0")]
+		public static string PtrToStringAnsi(IntPtr ptr)
+		{
+			return null;
+		}
+
+		/// <summary>Allocates a managed <see cref="T:System.String" />, copies a specified number of characters from an unmanaged ANSI string into it, and widens each ANSI character to Unicode.</summary>
+		/// <param name="ptr">The address of the first character of the unmanaged string.</param>
+		/// <param name="len">The byte count of the input string to copy.</param>
+		/// <returns>A managed string that holds a copy of the native ANSI string if the value of the <paramref name="ptr" /> parameter is not <see langword="null" />; otherwise, this method returns <see langword="null" />.</returns>
+		/// <exception cref="T:System.ArgumentException">
+		///   <paramref name="len" /> is less than zero.</exception>
+		// Token: 0x06002D1B RID: 11547 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002D1B")]
+		[Address(RVA = "0x2CF27E0", Offset = "0x2CF17E0", VA = "0x182CF27E0")]
+		public static string PtrToStringAnsi(IntPtr ptr, int len)
+		{
+			return null;
+		}
+
+		/// <summary>Allocates a managed <see cref="T:System.String" /> and copies all characters up to the first null character from a string stored in unmanaged memory into it.</summary>
+		/// <param name="ptr">For Unicode platforms, the address of the first Unicode character.  
+		///  -or-  
+		///  For ANSI plaforms, the address of the first ANSI character.</param>
+		/// <returns>A managed string that holds a copy of the unmanaged string if the value of the <paramref name="ptr" /> parameter is not <see langword="null" />; otherwise, this method returns <see langword="null" />.</returns>
+		// Token: 0x06002D1C RID: 11548 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002D1C")]
+		[Address(RVA = "0x2CF2800", Offset = "0x2CF1800", VA = "0x182CF2800")]
+		public static string PtrToStringAuto(IntPtr ptr)
+		{
+			return null;
+		}
+
+		/// <summary>Allocates a managed <see cref="T:System.String" /> and copies all characters up to the first null character from an unmanaged Unicode string into it.</summary>
+		/// <param name="ptr">The address of the first character of the unmanaged string.</param>
+		/// <returns>A managed string that holds a copy of the unmanaged string if the value of the <paramref name="ptr" /> parameter is not <see langword="null" />; otherwise, this method returns <see langword="null" />.</returns>
+		// Token: 0x06002D1D RID: 11549 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002D1D")]
+		[Address(RVA = "0x2CF28B0", Offset = "0x2CF18B0", VA = "0x182CF28B0")]
+		public static string PtrToStringUni(IntPtr ptr)
+		{
+			return null;
+		}
+
+		/// <summary>Allocates a managed <see cref="T:System.String" /> and copies a binary string (BSTR) stored in unmanaged memory into it.</summary>
+		/// <param name="ptr">The address of the first character of the unmanaged string.</param>
+		/// <returns>A managed string that holds a copy of the unmanaged string.</returns>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="ptr" /> equals <see cref="F:System.IntPtr.Zero" />.</exception>
+		// Token: 0x06002D1E RID: 11550 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002D1E")]
+		[Address(RVA = "0x2CF28A0", Offset = "0x2CF18A0", VA = "0x182CF28A0")]
+		public static string PtrToStringBSTR(IntPtr ptr)
+		{
+			return null;
+		}
+
+		/// <summary>Marshals data from an unmanaged block of memory to a managed object.</summary>
+		/// <param name="ptr">A pointer to an unmanaged block of memory.</param>
+		/// <param name="structure">The object to which the data is to be copied. This must be an instance of a formatted class.</param>
+		/// <exception cref="T:System.ArgumentException">Structure layout is not sequential or explicit.  
+		///  -or-  
+		///  Structure is a boxed value type.</exception>
+		// Token: 0x06002D1F RID: 11551 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002D1F")]
+		[Address(RVA = "0x2CF28C0", Offset = "0x2CF18C0", VA = "0x182CF28C0")]
+		[ComVisible(true)]
+		public static void PtrToStructure(IntPtr ptr, object structure)
+		{
+		}
+
+		/// <summary>Marshals data from an unmanaged block of memory to a newly allocated managed object of the specified type.</summary>
+		/// <param name="ptr">A pointer to an unmanaged block of memory.</param>
+		/// <param name="structureType">The type of object to be created. This object must represent a formatted class or a structure.</param>
+		/// <returns>A managed object containing the data pointed to by the <paramref name="ptr" /> parameter.</returns>
+		/// <exception cref="T:System.ArgumentException">The <paramref name="structureType" /> parameter layout is not sequential or explicit.  
+		///  -or-  
+		///  The <paramref name="structureType" /> parameter is a generic type definition.</exception>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="structureType" /> is <see langword="null" />.</exception>
+		/// <exception cref="T:System.MissingMethodException">The class specified by <paramref name="structureType" /> does not have an accessible default constructor.</exception>
+		// Token: 0x06002D20 RID: 11552 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002D20")]
+		[Address(RVA = "0x2CF28D0", Offset = "0x2CF18D0", VA = "0x182CF28D0")]
+		[ComVisible(true)]
+		public static object PtrToStructure(IntPtr ptr, Type structureType)
+		{
+			return null;
+		}
+
+		/// <summary>[Supported in the .NET Framework 4.5.1 and later versions]  
+		///  Marshals data from an unmanaged block of memory to a managed object of the specified type.</summary>
+		/// <param name="ptr">A pointer to an unmanaged block of memory.</param>
+		/// <param name="structure">The object to which the data is to be copied.</param>
+		/// <typeparam name="T">The type of <paramref name="structure" />. This must be a formatted class.</typeparam>
+		/// <exception cref="T:System.ArgumentException">Structure layout is not sequential or explicit.</exception>
+		// Token: 0x06002D21 RID: 11553 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002D21")]
+		[Address(RVA = "0x1FD72A0", Offset = "0x1FD62A0", VA = "0x181FD72A0")]
+		public static void PtrToStructure<T>(IntPtr ptr, T structure)
+		{
+		}
+
+		/// <summary>[Supported in the .NET Framework 4.5.1 and later versions]  
+		///  Marshals data from an unmanaged block of memory to a newly allocated managed object of the type specified by a generic type parameter.</summary>
+		/// <param name="ptr">A pointer to an unmanaged block of memory.</param>
+		/// <typeparam name="T">The type of the object to which the data is to be copied. This must be a formatted class or a structure.</typeparam>
+		/// <returns>A managed object that contains the data that the <paramref name="ptr" /> parameter points to.</returns>
+		/// <exception cref="T:System.ArgumentException">The layout of <typeparamref name="T" /> is not sequential or explicit.</exception>
+		/// <exception cref="T:System.MissingMethodException">The class specified by <typeparamref name="T" /> does not have an accessible default constructor.</exception>
+		// Token: 0x06002D22 RID: 11554 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002D22")]
+		[Address(RVA = "0x1E5F400", Offset = "0x1E5E400", VA = "0x181E5F400")]
+		public static T PtrToStructure<T>(IntPtr ptr)
+		{
+			return null;
+		}
+
+		/// <summary>Reads a single byte at a given offset (or index) from unmanaged memory.</summary>
+		/// <param name="ptr">The base address in unmanaged memory from which to read.</param>
+		/// <param name="ofs">An additional byte offset, which is added to the <paramref name="ptr" /> parameter before reading.</param>
+		/// <returns>The byte read from unmanaged memory at the given offset.</returns>
+		/// <exception cref="T:System.AccessViolationException">Base address (<paramref name="ptr" />) plus offset byte (<paramref name="ofs" />) produces a null or invalid address.</exception>
+		// Token: 0x06002D23 RID: 11555 RVA: 0x000190B0 File Offset: 0x000172B0
+		[Token(Token = "0x6002D23")]
+		[Address(RVA = "0x2CF28E0", Offset = "0x2CF18E0", VA = "0x182CF28E0")]
+		public static byte ReadByte(IntPtr ptr, int ofs)
+		{
+			return 0;
+		}
+
+		/// <summary>Reads a 16-bit signed integer at a given offset from unmanaged memory.</summary>
+		/// <param name="ptr">The base address in unmanaged memory from which to read.</param>
+		/// <param name="ofs">An additional byte offset, which is added to the <paramref name="ptr" /> parameter before reading.</param>
+		/// <returns>The 16-bit signed integer read from unmanaged memory at the given offset.</returns>
+		/// <exception cref="T:System.AccessViolationException">Base address (<paramref name="ptr" />) plus offset byte (<paramref name="ofs" />) produces a null or invalid address.</exception>
+		// Token: 0x06002D24 RID: 11556 RVA: 0x000190C8 File Offset: 0x000172C8
+		[Token(Token = "0x6002D24")]
+		[Address(RVA = "0x2CF2900", Offset = "0x2CF1900", VA = "0x182CF2900")]
+		public static short ReadInt16(IntPtr ptr, int ofs)
+		{
+			return 0;
+		}
+
+		/// <summary>Reads a 32-bit signed integer from unmanaged memory.</summary>
+		/// <param name="ptr">The address in unmanaged memory from which to read.</param>
+		/// <returns>The 32-bit signed integer read from unmanaged memory.</returns>
+		/// <exception cref="T:System.AccessViolationException">
+		///   <paramref name="ptr" /> is not a recognized format.  
+		/// -or-  
+		/// <paramref name="ptr" /> is <see langword="null" />.  
+		/// -or-  
+		/// <paramref name="ptr" /> is invalid.</exception>
+		// Token: 0x06002D25 RID: 11557 RVA: 0x000190E0 File Offset: 0x000172E0
+		[Token(Token = "0x6002D25")]
+		[Address(RVA = "0x2CF2950", Offset = "0x2CF1950", VA = "0x182CF2950")]
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
+		public static int ReadInt32(IntPtr ptr)
+		{
+			return 0;
+		}
+
+		/// <summary>Reads a 32-bit signed integer at a given offset from unmanaged memory.</summary>
+		/// <param name="ptr">The base address in unmanaged memory from which to read.</param>
+		/// <param name="ofs">An additional byte offset, which is added to the <paramref name="ptr" /> parameter before reading.</param>
+		/// <returns>The 32-bit signed integer read from unmanaged memory.</returns>
+		/// <exception cref="T:System.AccessViolationException">Base address (<paramref name="ptr" />) plus offset byte (<paramref name="ofs" />) produces a null or invalid address.</exception>
+		// Token: 0x06002D26 RID: 11558 RVA: 0x000190F8 File Offset: 0x000172F8
+		[Token(Token = "0x6002D26")]
+		[Address(RVA = "0x2CF2990", Offset = "0x2CF1990", VA = "0x182CF2990")]
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
+		public static int ReadInt32(IntPtr ptr, int ofs)
+		{
+			return 0;
+		}
+
+		/// <summary>Reads a 64-bit signed integer from unmanaged memory.</summary>
+		/// <param name="ptr">The address in unmanaged memory from which to read.</param>
+		/// <returns>The 64-bit signed integer read from unmanaged memory.</returns>
+		/// <exception cref="T:System.AccessViolationException">
+		///   <paramref name="ptr" /> is not a recognized format.  
+		/// -or-  
+		/// <paramref name="ptr" /> is <see langword="null" />.  
+		/// -or-  
+		/// <paramref name="ptr" /> is invalid.</exception>
+		// Token: 0x06002D27 RID: 11559 RVA: 0x00019110 File Offset: 0x00017310
+		[Token(Token = "0x6002D27")]
+		[Address(RVA = "0x2CF2A30", Offset = "0x2CF1A30", VA = "0x182CF2A30")]
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
+		public static long ReadInt64(IntPtr ptr)
+		{
+			return 0L;
+		}
+
+		/// <summary>Reads a 64-bit signed integer at a given offset from unmanaged memory.</summary>
+		/// <param name="ptr">The base address in unmanaged memory from which to read.</param>
+		/// <param name="ofs">An additional byte offset, which is added to the <paramref name="ptr" /> parameter before reading.</param>
+		/// <returns>The 64-bit signed integer read from unmanaged memory at the given offset.</returns>
+		/// <exception cref="T:System.AccessViolationException">Base address (<paramref name="ptr" />) plus offset byte (<paramref name="ofs" />) produces a null or invalid address.</exception>
+		// Token: 0x06002D28 RID: 11560 RVA: 0x00019128 File Offset: 0x00017328
+		[Token(Token = "0x6002D28")]
+		[Address(RVA = "0x2CF29E0", Offset = "0x2CF19E0", VA = "0x182CF29E0")]
+		public static long ReadInt64(IntPtr ptr, int ofs)
+		{
+			return 0L;
+		}
+
+		/// <summary>Reads a processor native-sized integer from unmanaged memory.</summary>
+		/// <param name="ptr">The address in unmanaged memory from which to read.</param>
+		/// <returns>The integer read from unmanaged memory. A 32 bit integer is returned on 32 bit machines and a 64 bit integer is returned on 64 bit machines.</returns>
+		/// <exception cref="T:System.AccessViolationException">
+		///   <paramref name="ptr" /> is not a recognized format.  
+		/// -or-  
+		/// <paramref name="ptr" /> is <see langword="null" />.  
+		/// -or-  
+		/// <paramref name="ptr" /> is invalid.</exception>
+		// Token: 0x06002D29 RID: 11561 RVA: 0x00019140 File Offset: 0x00017340
+		[Token(Token = "0x6002D29")]
+		[Address(RVA = "0x2CF2BA0", Offset = "0x2CF1BA0", VA = "0x182CF2BA0")]
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
+		public static IntPtr ReadIntPtr(IntPtr ptr)
+		{
+			return 0;
+		}
+
+		/// <summary>Reads a processor native sized integer at a given offset from unmanaged memory.</summary>
+		/// <param name="ptr">The base address in unmanaged memory from which to read.</param>
+		/// <param name="ofs">An additional byte offset, which is added to the <paramref name="ptr" /> parameter before reading.</param>
+		/// <returns>The integer read from unmanaged memory at the given offset.</returns>
+		/// <exception cref="T:System.AccessViolationException">Base address (<paramref name="ptr" />) plus offset byte (<paramref name="ofs" />) produces a null or invalid address.</exception>
+		// Token: 0x06002D2A RID: 11562 RVA: 0x00019158 File Offset: 0x00017358
+		[Token(Token = "0x6002D2A")]
+		[Address(RVA = "0x2CF2A80", Offset = "0x2CF1A80", VA = "0x182CF2A80")]
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
+		public static IntPtr ReadIntPtr(IntPtr ptr, int ofs)
+		{
+			return 0;
+		}
+
+		// Token: 0x06002D2B RID: 11563 RVA: 0x00019170 File Offset: 0x00017370
+		[Token(Token = "0x6002D2B")]
+		[Address(RVA = "0x2CF2CB0", Offset = "0x2CF1CB0", VA = "0x182CF2CB0")]
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
+		private static int ReleaseInternal(IntPtr pUnk)
+		{
+			return 0;
+		}
+
+		/// <summary>Decrements the reference count on the specified interface.</summary>
+		/// <param name="pUnk">The interface to release.</param>
+		/// <returns>The new value of the reference count on the interface specified by the <paramref name="pUnk" /> parameter.</returns>
+		// Token: 0x06002D2C RID: 11564 RVA: 0x00019188 File Offset: 0x00017388
+		[Token(Token = "0x6002D2C")]
+		[Address(RVA = "0x2CF2CC0", Offset = "0x2CF1CC0", VA = "0x182CF2CC0")]
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
+		public static int Release(IntPtr pUnk)
+		{
+			return 0;
+		}
+
+		/// <summary>Returns the unmanaged size of an object in bytes.</summary>
+		/// <param name="structure">The object whose size is to be returned.</param>
+		/// <returns>The size of the specified object in unmanaged code.</returns>
+		/// <exception cref="T:System.ArgumentNullException">The <paramref name="structure" /> parameter is <see langword="null" />.</exception>
+		// Token: 0x06002D2D RID: 11565 RVA: 0x000191A0 File Offset: 0x000173A0
+		[Token(Token = "0x6002D2D")]
+		[Address(RVA = "0x2CF31D0", Offset = "0x2CF21D0", VA = "0x182CF31D0")]
+		[ComVisible(true)]
+		public static int SizeOf(object structure)
+		{
+			return 0;
+		}
+
+		/// <summary>Returns the size of an unmanaged type in bytes.</summary>
+		/// <param name="t">The type whose size is to be returned.</param>
+		/// <returns>The size of the specified type in unmanaged code.</returns>
+		/// <exception cref="T:System.ArgumentException">The <paramref name="t" /> parameter is a generic type definition.</exception>
+		/// <exception cref="T:System.ArgumentNullException">The <paramref name="t" /> parameter is <see langword="null" />.</exception>
+		// Token: 0x06002D2E RID: 11566 RVA: 0x000191B8 File Offset: 0x000173B8
+		[Token(Token = "0x6002D2E")]
+		[Address(RVA = "0x2CF31C0", Offset = "0x2CF21C0", VA = "0x182CF31C0")]
+		public static int SizeOf(Type t)
+		{
+			return 0;
+		}
+
+		/// <summary>[Supported in the .NET Framework 4.5.1 and later versions]  
+		///  Returns the size of an unmanaged type in bytes.</summary>
+		/// <typeparam name="T">The type whose size is to be returned.</typeparam>
+		/// <returns>The size, in bytes, of the type that is specified by the <typeparamref name="T" /> generic type parameter.</returns>
+		// Token: 0x06002D2F RID: 11567 RVA: 0x000191D0 File Offset: 0x000173D0
+		[Token(Token = "0x6002D2F")]
+		[Address(RVA = "0x27D7D40", Offset = "0x27D6D40", VA = "0x1827D7D40")]
+		public static int SizeOf<T>()
+		{
+			return 0;
+		}
+
+		/// <summary>[Supported in the .NET Framework 4.5.1 and later versions]  
+		///  Returns the unmanaged size of an object of a specified type in bytes.</summary>
+		/// <param name="structure">The object whose size is to be returned.</param>
+		/// <typeparam name="T">The type of the <paramref name="structure" /> parameter.</typeparam>
+		/// <returns>The size, in bytes, of the specified object in unmanaged code.</returns>
+		/// <exception cref="T:System.ArgumentNullException">The <paramref name="structure" /> parameter is <see langword="null" />.</exception>
+		// Token: 0x06002D30 RID: 11568 RVA: 0x000191E8 File Offset: 0x000173E8
+		[Token(Token = "0x6002D30")]
+		[Address(RVA = "0x27D7DD0", Offset = "0x27D6DD0", VA = "0x1827D7DD0")]
+		public static int SizeOf<T>(T structure)
+		{
+			return 0;
+		}
+
+		/// <summary>Allocates a BSTR and copies the contents of a managed <see cref="T:System.String" /> into it.</summary>
+		/// <param name="s">The managed string to be copied.</param>
+		/// <returns>An unmanaged pointer to the <see langword="BSTR" />, or 0 if <paramref name="s" /> is null.</returns>
+		/// <exception cref="T:System.OutOfMemoryException">There is insufficient memory available.</exception>
+		/// <exception cref="T:System.ArgumentOutOfRangeException">The length for <paramref name="s" /> is out of range.</exception>
+		// Token: 0x06002D31 RID: 11569 RVA: 0x00019200 File Offset: 0x00017400
+		[Token(Token = "0x6002D31")]
+		[Address(RVA = "0x2CF3240", Offset = "0x2CF2240", VA = "0x182CF3240")]
+		public static IntPtr StringToBSTR(string s)
+		{
+			return 0;
+		}
+
+		/// <summary>Copies the contents of a managed <see cref="T:System.String" /> into unmanaged memory.</summary>
+		/// <param name="s">A managed string to be copied.</param>
+		/// <returns>The address, in unmanaged memory, to where the <paramref name="s" /> was copied, or 0 if <paramref name="s" /> is <see langword="null" />.</returns>
+		/// <exception cref="T:System.OutOfMemoryException">The method could not allocate enough native heap memory.</exception>
+		/// <exception cref="T:System.ArgumentOutOfRangeException">The <paramref name="s" /> parameter exceeds the maximum length allowed by the operating system.</exception>
+		// Token: 0x06002D32 RID: 11570 RVA: 0x00019218 File Offset: 0x00017418
+		[Token(Token = "0x6002D32")]
+		[Address(RVA = "0x2CF3250", Offset = "0x2CF2250", VA = "0x182CF3250")]
+		public static IntPtr StringToHGlobalUni(string s)
+		{
+			return 0;
+		}
+
+		/// <summary>Allocates an unmanaged binary string (BSTR) and copies the contents of a managed <see cref="T:System.Security.SecureString" /> object into it.</summary>
+		/// <param name="s">The managed object to copy.</param>
+		/// <returns>The address, in unmanaged memory, where the <paramref name="s" /> parameter was copied to, or 0 if a null object was supplied.</returns>
+		/// <exception cref="T:System.ArgumentNullException">The <paramref name="s" /> parameter is <see langword="null" />.</exception>
+		/// <exception cref="T:System.NotSupportedException">The current computer is not running Windows 2000 Service Pack 3 or later.</exception>
+		/// <exception cref="T:System.OutOfMemoryException">There is insufficient memory available.</exception>
+		// Token: 0x06002D33 RID: 11571 RVA: 0x00019230 File Offset: 0x00017430
+		[Token(Token = "0x6002D33")]
+		[Address(RVA = "0x2CF2D60", Offset = "0x2CF1D60", VA = "0x182CF2D60")]
+		public static IntPtr SecureStringToBSTR(SecureString s)
+		{
+			return 0;
+		}
+
+		/// <summary>Copies the contents of a managed <see cref="T:System.Security.SecureString" /> object to a block of memory allocated from the unmanaged COM task allocator.</summary>
+		/// <param name="s">The managed object to copy.</param>
+		/// <returns>The address, in unmanaged memory, where the <paramref name="s" /> parameter was copied to, or 0 if a null object was supplied.</returns>
+		/// <exception cref="T:System.ArgumentNullException">The <paramref name="s" /> parameter is <see langword="null" />.</exception>
+		/// <exception cref="T:System.NotSupportedException">The current computer is not running Windows 2000 Service Pack 3 or later.</exception>
+		/// <exception cref="T:System.OutOfMemoryException">There is insufficient memory available.</exception>
+		// Token: 0x06002D34 RID: 11572 RVA: 0x00019248 File Offset: 0x00017448
+		[Token(Token = "0x6002D34")]
+		[Address(RVA = "0x2CF2ED0", Offset = "0x2CF1ED0", VA = "0x182CF2ED0")]
+		public static IntPtr SecureStringToCoTaskMemUnicode(SecureString s)
+		{
+			return 0;
+		}
+
+		/// <summary>Copies the contents of a managed <see cref="T:System.Security.SecureString" /> object into unmanaged memory.</summary>
+		/// <param name="s">The managed object to copy.</param>
+		/// <returns>The address, in unmanaged memory, where <paramref name="s" /> was copied, or 0 if <paramref name="s" /> is a <see cref="T:System.Security.SecureString" /> object whose length is 0.</returns>
+		/// <exception cref="T:System.ArgumentNullException">The <paramref name="s" /> parameter is <see langword="null" />.</exception>
+		/// <exception cref="T:System.NotSupportedException">The current computer is not running Windows 2000 Service Pack 3 or later.</exception>
+		/// <exception cref="T:System.OutOfMemoryException">There is insufficient memory available.</exception>
+		// Token: 0x06002D35 RID: 11573 RVA: 0x00019260 File Offset: 0x00017460
+		[Token(Token = "0x6002D35")]
+		[Address(RVA = "0x2CF3130", Offset = "0x2CF2130", VA = "0x182CF3130")]
+		public static IntPtr SecureStringToGlobalAllocUnicode(SecureString s)
+		{
+			return 0;
+		}
+
+		/// <summary>Marshals data from a managed object to an unmanaged block of memory.</summary>
+		/// <param name="structure">A managed object that holds the data to be marshaled. This object must be a structure or an instance of a formatted class.</param>
+		/// <param name="ptr">A pointer to an unmanaged block of memory, which must be allocated before this method is called.</param>
+		/// <param name="fDeleteOld">
+		///   <see langword="true" /> to call the <see cref="M:System.Runtime.InteropServices.Marshal.DestroyStructure(System.IntPtr,System.Type)" /> method on the <paramref name="ptr" /> parameter before this method copies the data. The block must contain valid data. Note that passing <see langword="false" /> when the memory block already contains data can lead to a memory leak.</param>
+		/// <exception cref="T:System.ArgumentException">
+		///   <paramref name="structure" /> is a reference type that is not a formatted class.  
+		/// -or-  
+		/// <paramref name="structure" /> is an instance of a generic type (in the .NET Framework 4.5 and earlier versions only).</exception>
+		// Token: 0x06002D36 RID: 11574 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002D36")]
+		[Address(RVA = "0x2CF3260", Offset = "0x2CF2260", VA = "0x182CF3260")]
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
+		[ComVisible(true)]
+		public static void StructureToPtr(object structure, IntPtr ptr, bool fDeleteOld)
+		{
+		}
+
+		/// <summary>[Supported in the .NET Framework 4.5.1 and later versions]  
+		///  Marshals data from a managed object of a specified type to an unmanaged block of memory.</summary>
+		/// <param name="structure">A managed object that holds the data to be marshaled. The object must be a structure or an instance of a formatted class.</param>
+		/// <param name="ptr">A pointer to an unmanaged block of memory, which must be allocated before this method is called.</param>
+		/// <param name="fDeleteOld">
+		///   <see langword="true" /> to call the <see cref="M:System.Runtime.InteropServices.Marshal.DestroyStructure``1(System.IntPtr)" /> method on the <paramref name="ptr" /> parameter before this method copies the data. The block must contain valid data. Note that passing <see langword="false" /> when the memory block already contains data can lead to a memory leak.</param>
+		/// <typeparam name="T">The type of the managed object.</typeparam>
+		/// <exception cref="T:System.ArgumentException">
+		///   <paramref name="structure" /> is a reference type that is not a formatted class.</exception>
+		// Token: 0x06002D37 RID: 11575 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002D37")]
+		[Address(RVA = "0x1FD7310", Offset = "0x1FD6310", VA = "0x181FD7310")]
+		public static void StructureToPtr<T>(T structure, IntPtr ptr, bool fDeleteOld)
+		{
+		}
+
+		/// <summary>Throws an exception with a specific failure HRESULT value.</summary>
+		/// <param name="errorCode">The HRESULT corresponding to the desired exception.</param>
+		// Token: 0x06002D38 RID: 11576 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002D38")]
+		[Address(RVA = "0x2CF3270", Offset = "0x2CF2270", VA = "0x182CF3270")]
+		public static void ThrowExceptionForHR(int errorCode)
+		{
+		}
+
+		// Token: 0x06002D39 RID: 11577 RVA: 0x00019278 File Offset: 0x00017478
+		[Token(Token = "0x6002D39")]
+		[Address(RVA = "0x92BEF0", Offset = "0x92AEF0", VA = "0x18092BEF0")]
+		private static IntPtr BufferToBSTR(Array ptr, int slen)
+		{
+			return 0;
+		}
+
+		/// <summary>Gets the address of the element at the specified index inside the specified array.</summary>
+		/// <param name="arr">The array that contains the desired element.</param>
+		/// <param name="index">The index in the <paramref name="arr" /> parameter of the desired element.</param>
+		/// <returns>The address of <paramref name="index" /> inside <paramref name="arr" />.</returns>
+		// Token: 0x06002D3A RID: 11578 RVA: 0x00019290 File Offset: 0x00017490
+		[Token(Token = "0x6002D3A")]
+		[Address(RVA = "0x2CF3360", Offset = "0x2CF2360", VA = "0x182CF3360")]
+		public static IntPtr UnsafeAddrOfPinnedArrayElement(Array arr, int index)
+		{
+			return 0;
+		}
+
+		/// <summary>[Supported in the .NET Framework 4.5.1 and later versions]  
+		///  Gets the address of the element at the specified index in an array of a specified type.</summary>
+		/// <param name="arr">The array that contains the desired element.</param>
+		/// <param name="index">The index of the desired element in the <paramref name="arr" /> array.</param>
+		/// <typeparam name="T">The type of the array.</typeparam>
+		/// <returns>The address of <paramref name="index" /> in <paramref name="arr" />.</returns>
+		// Token: 0x06002D3B RID: 11579 RVA: 0x000192A8 File Offset: 0x000174A8
+		[Token(Token = "0x6002D3B")]
+		[Address(RVA = "0x27D8490", Offset = "0x27D7490", VA = "0x1827D8490")]
+		public static IntPtr UnsafeAddrOfPinnedArrayElement<T>(T[] arr, int index)
+		{
+			return 0;
+		}
+
+		/// <summary>Writes a single byte value to unmanaged memory at a specified offset.</summary>
+		/// <param name="ptr">The base address in unmanaged memory to write to.</param>
+		/// <param name="ofs">An additional byte offset, which is added to the <paramref name="ptr" /> parameter before writing.</param>
+		/// <param name="val">The value to write.</param>
+		/// <exception cref="T:System.AccessViolationException">Base address (<paramref name="ptr" />) plus offset byte (<paramref name="ofs" />) produces a null or invalid address.</exception>
+		// Token: 0x06002D3C RID: 11580 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002D3C")]
+		[Address(RVA = "0x2CF3370", Offset = "0x2CF2370", VA = "0x182CF3370")]
+		public static void WriteByte(IntPtr ptr, int ofs, byte val)
+		{
+		}
+
+		/// <summary>Writes a 16-bit signed integer value into unmanaged memory at a specified offset.</summary>
+		/// <param name="ptr">The base address in unmanaged memory to write to.</param>
+		/// <param name="ofs">An additional byte offset, which is added to the <paramref name="ptr" /> parameter before writing.</param>
+		/// <param name="val">The value to write.</param>
+		/// <exception cref="T:System.AccessViolationException">Base address (<paramref name="ptr" />) plus offset byte (<paramref name="ofs" />) produces a null or invalid address.</exception>
+		// Token: 0x06002D3D RID: 11581 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002D3D")]
+		[Address(RVA = "0x2CF33A0", Offset = "0x2CF23A0", VA = "0x182CF33A0")]
+		public static void WriteInt16(IntPtr ptr, int ofs, short val)
+		{
+		}
+
+		/// <summary>Writes a 32-bit signed integer value to unmanaged memory.</summary>
+		/// <param name="ptr">The address in unmanaged memory to write to.</param>
+		/// <param name="val">The value to write.</param>
+		/// <exception cref="T:System.AccessViolationException">
+		///   <paramref name="ptr" /> is not a recognized format.  
+		/// -or-  
+		/// <paramref name="ptr" /> is <see langword="null" />.  
+		/// -or-  
+		/// <paramref name="ptr" /> is invalid.</exception>
+		// Token: 0x06002D3E RID: 11582 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002D3E")]
+		[Address(RVA = "0x2CF33F0", Offset = "0x2CF23F0", VA = "0x182CF33F0")]
+		public static void WriteInt32(IntPtr ptr, int val)
+		{
+		}
+
+		/// <summary>Writes a 64-bit signed integer value to unmanaged memory.</summary>
+		/// <param name="ptr">The address in unmanaged memory to write to.</param>
+		/// <param name="val">The value to write.</param>
+		/// <exception cref="T:System.AccessViolationException">
+		///   <paramref name="ptr" /> is not a recognized format.  
+		/// -or-  
+		/// <paramref name="ptr" /> is <see langword="null" />.  
+		/// -or-  
+		/// <paramref name="ptr" /> is invalid.</exception>
+		// Token: 0x06002D3F RID: 11583 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002D3F")]
+		[Address(RVA = "0x2CF3430", Offset = "0x2CF2430", VA = "0x182CF3430")]
+		public static void WriteInt64(IntPtr ptr, long val)
+		{
+		}
+
+		/// <summary>Writes a processor native sized integer value into unmanaged memory.</summary>
+		/// <param name="ptr">The address in unmanaged memory to write to.</param>
+		/// <param name="val">The value to write.</param>
+		/// <exception cref="T:System.AccessViolationException">
+		///   <paramref name="ptr" /> is not a recognized format.  
+		/// -or-  
+		/// <paramref name="ptr" /> is <see langword="null" />.  
+		/// -or-  
+		/// <paramref name="ptr" /> is invalid.</exception>
+		// Token: 0x06002D40 RID: 11584 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002D40")]
+		[Address(RVA = "0x2CF3470", Offset = "0x2CF2470", VA = "0x182CF3470")]
+		public static void WriteIntPtr(IntPtr ptr, IntPtr val)
+		{
+		}
+
+		// Token: 0x06002D41 RID: 11585 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002D41")]
+		[Address(RVA = "0x2CF12F0", Offset = "0x2CF02F0", VA = "0x182CF12F0")]
+		private static Exception ConvertHrToException(int errorCode)
+		{
+			return null;
+		}
+
+		/// <summary>Converts the specified HRESULT error code to a corresponding <see cref="T:System.Exception" /> object.</summary>
+		/// <param name="errorCode">The HRESULT to be converted.</param>
+		/// <returns>An object that represents the converted HRESULT.</returns>
+		// Token: 0x06002D42 RID: 11586 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002D42")]
+		[Address(RVA = "0x2CF2710", Offset = "0x2CF1710", VA = "0x182CF2710")]
+		public static Exception GetExceptionForHR(int errorCode)
+		{
+			return null;
+		}
+
+		/// <summary>Converts the specified HRESULT error code to a corresponding <see cref="T:System.Exception" /> object, with additional error information passed in an IErrorInfo interface for the exception object.</summary>
+		/// <param name="errorCode">The HRESULT to be converted.</param>
+		/// <param name="errorInfo">A pointer to the <see langword="IErrorInfo" /> interface that provides more information about the error. You can specify IntPtr(0) to use the current <see langword="IErrorInfo" /> interface, or IntPtr(-1) to ignore the current <see langword="IErrorInfo" /> interface and construct the exception just from the error code.</param>
+		/// <returns>An object that represents the converted HRESULT and information obtained from <paramref name="errorInfo" />.</returns>
+		// Token: 0x06002D43 RID: 11587 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002D43")]
+		[Address(RVA = "0x2CF26C0", Offset = "0x2CF16C0", VA = "0x182CF26C0")]
+		public static Exception GetExceptionForHR(int errorCode, IntPtr errorInfo)
+		{
+			return null;
+		}
+
+		// Token: 0x06002D44 RID: 11588 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002D44")]
+		[Address(RVA = "0x2CF2470", Offset = "0x2CF1470", VA = "0x182CF2470")]
+		private static Delegate GetDelegateForFunctionPointerInternal(IntPtr ptr, Type t)
+		{
+			return null;
+		}
+
+		/// <summary>Converts an unmanaged function pointer to a delegate.</summary>
+		/// <param name="ptr">The unmanaged function pointer to be converted.</param>
+		/// <param name="t">The type of the delegate to be returned.</param>
+		/// <returns>A delegate instance that can be cast to the appropriate delegate type.</returns>
+		/// <exception cref="T:System.ArgumentException">The <paramref name="t" /> parameter is not a delegate or is generic.</exception>
+		/// <exception cref="T:System.ArgumentNullException">The <paramref name="ptr" /> parameter is <see langword="null" />.  
+		///  -or-  
+		///  The <paramref name="t" /> parameter is <see langword="null" />.</exception>
+		// Token: 0x06002D45 RID: 11589 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002D45")]
+		[Address(RVA = "0x2CF2480", Offset = "0x2CF1480", VA = "0x182CF2480")]
+		public static Delegate GetDelegateForFunctionPointer(IntPtr ptr, Type t)
+		{
+			return null;
+		}
+
+		/// <summary>[Supported in the .NET Framework 4.5.1 and later versions]  
+		///  Converts an unmanaged function pointer to a delegate of a specified type.</summary>
+		/// <param name="ptr">The unmanaged function pointer to convert.</param>
+		/// <typeparam name="TDelegate">The type of the delegate to return.</typeparam>
+		/// <returns>A instance of the specified delegate type.</returns>
+		/// <exception cref="T:System.ArgumentException">The <paramref name="TDelegate" /> generic parameter is not a delegate, or it is an open generic type.</exception>
+		/// <exception cref="T:System.ArgumentNullException">The <paramref name="ptr" /> parameter is <see langword="null" />.</exception>
+		// Token: 0x06002D46 RID: 11590 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002D46")]
+		[Address(RVA = "0x1E5F320", Offset = "0x1E5E320", VA = "0x181E5F320")]
+		public static TDelegate GetDelegateForFunctionPointer<TDelegate>(IntPtr ptr)
+		{
+			return null;
+		}
+
+		// Token: 0x06002D47 RID: 11591 RVA: 0x000192C0 File Offset: 0x000174C0
+		[Token(Token = "0x6002D47")]
+		[Address(RVA = "0x2CF27A0", Offset = "0x2CF17A0", VA = "0x182CF27A0")]
+		private static IntPtr GetFunctionPointerForDelegateInternal(Delegate d)
+		{
+			return 0;
+		}
+
+		/// <summary>[Supported in the .NET Framework 4.5.1 and later versions]  
+		///  Converts a delegate of a specified type to a function pointer that is callable from unmanaged code.</summary>
+		/// <param name="d">The delegate to be passed to unmanaged code.</param>
+		/// <typeparam name="TDelegate">The type of delegate to convert.</typeparam>
+		/// <returns>A value that can be passed to unmanaged code, which, in turn, can use it to call the underlying managed delegate.</returns>
+		/// <exception cref="T:System.ArgumentException">The <paramref name="d" /> parameter is a generic type definition.</exception>
+		/// <exception cref="T:System.ArgumentNullException">The <paramref name="d" /> parameter is <see langword="null" />.</exception>
+		// Token: 0x06002D48 RID: 11592 RVA: 0x000192D8 File Offset: 0x000174D8
+		[Token(Token = "0x6002D48")]
+		[Address(RVA = "0x27D7C80", Offset = "0x27D6C80", VA = "0x1827D7C80")]
+		public static IntPtr GetFunctionPointerForDelegate<TDelegate>(TDelegate d)
+		{
+			return 0;
+		}
+
+		/// <summary>Represents the maximum size of a double byte character set (DBCS) size, in bytes, for the current operating system. This field is read-only.</summary>
+		// Token: 0x04001A04 RID: 6660
+		[Token(Token = "0x4001A04")]
+		public static readonly int SystemMaxDBCSCharSize;
+
+		/// <summary>Represents the default character size on the system; the default is 2 for Unicode systems and 1 for ANSI systems. This field is read-only.</summary>
+		// Token: 0x04001A05 RID: 6661
+		[Token(Token = "0x4001A05")]
+		public static readonly int SystemDefaultCharSize;
+	}
+}

mscorlib/System/Runtime/InteropServices/MarshalAsAttribute.cs

@@ -0,0 +1,83 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Indicates how to marshal the data between managed and unmanaged code.</summary>
+	// Token: 0x020005A8 RID: 1448
+	[Token(Token = "0x20005A8")]
+	[AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue)]
+	[ComVisible(true)]
+	[StructLayout(0)]
+	public sealed class MarshalAsAttribute : Attribute
+	{
+		// Token: 0x06002D4A RID: 11594 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002D4A")]
+		[Address(RVA = "0x2CF0EE0", Offset = "0x2CEFEE0", VA = "0x182CF0EE0")]
+		internal MarshalAsAttribute Copy()
+		{
+			return null;
+		}
+
+		/// <summary>Provides additional information to a custom marshaler.</summary>
+		// Token: 0x04001A06 RID: 6662
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x4001A06")]
+		public string MarshalCookie;
+
+		/// <summary>Specifies the fully qualified name of a custom marshaler.</summary>
+		// Token: 0x04001A07 RID: 6663
+		[FieldOffset(Offset = "0x18")]
+		[Token(Token = "0x4001A07")]
+		[ComVisible(true)]
+		public string MarshalType;
+
+		/// <summary>Implements <see cref="F:System.Runtime.InteropServices.MarshalAsAttribute.MarshalType" /> as a type.</summary>
+		// Token: 0x04001A08 RID: 6664
+		[FieldOffset(Offset = "0x20")]
+		[Token(Token = "0x4001A08")]
+		[ComVisible(true)]
+		public Type MarshalTypeRef;
+
+		/// <summary>Indicates the user-defined element type of the <see cref="F:System.Runtime.InteropServices.UnmanagedType.SafeArray" />.</summary>
+		// Token: 0x04001A09 RID: 6665
+		[FieldOffset(Offset = "0x28")]
+		[Token(Token = "0x4001A09")]
+		public Type SafeArrayUserDefinedSubType;
+
+		// Token: 0x04001A0A RID: 6666
+		[FieldOffset(Offset = "0x30")]
+		[Token(Token = "0x4001A0A")]
+		private UnmanagedType utype;
+
+		/// <summary>Specifies the element type of the unmanaged <see cref="F:System.Runtime.InteropServices.UnmanagedType.LPArray" /> or <see cref="F:System.Runtime.InteropServices.UnmanagedType.ByValArray" />.</summary>
+		// Token: 0x04001A0B RID: 6667
+		[FieldOffset(Offset = "0x34")]
+		[Token(Token = "0x4001A0B")]
+		public UnmanagedType ArraySubType;
+
+		/// <summary>Indicates the element type of the <see cref="F:System.Runtime.InteropServices.UnmanagedType.SafeArray" />.</summary>
+		// Token: 0x04001A0C RID: 6668
+		[FieldOffset(Offset = "0x38")]
+		[Token(Token = "0x4001A0C")]
+		public VarEnum SafeArraySubType;
+
+		/// <summary>Indicates the number of elements in the fixed-length array or the number of characters (not bytes) in a string to import.</summary>
+		// Token: 0x04001A0D RID: 6669
+		[FieldOffset(Offset = "0x3C")]
+		[Token(Token = "0x4001A0D")]
+		public int SizeConst;
+
+		/// <summary>Specifies the parameter index of the unmanaged <see langword="iid_is" /> attribute used by COM.</summary>
+		// Token: 0x04001A0E RID: 6670
+		[FieldOffset(Offset = "0x40")]
+		[Token(Token = "0x4001A0E")]
+		public int IidParameterIndex;
+
+		/// <summary>Indicates the zero-based parameter that contains the count of array elements, similar to <see langword="size_is" /> in COM.</summary>
+		// Token: 0x04001A0F RID: 6671
+		[FieldOffset(Offset = "0x44")]
+		[Token(Token = "0x4001A0F")]
+		public short SizeParamIndex;
+	}
+}

mscorlib/System/Runtime/InteropServices/MarshalDirectiveException.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Runtime.Serialization;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>The exception that is thrown by the marshaler when it encounters a <see cref="T:System.Runtime.InteropServices.MarshalAsAttribute" /> it does not support.</summary>
+	// Token: 0x020005A2 RID: 1442
+	[Token(Token = "0x20005A2")]
+	[ComVisible(true)]
+	[Serializable]
+	public class MarshalDirectiveException : SystemException
+	{
+		/// <summary>Initializes a new instance of the <see langword="MarshalDirectiveException" /> class with default properties.</summary>
+		// Token: 0x06002CD4 RID: 11476 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CD4")]
+		[Address(RVA = "0x2CF0F40", Offset = "0x2CEFF40", VA = "0x182CF0F40")]
+		public MarshalDirectiveException()
+		{
+		}
+
+		/// <summary>Initializes a new instance of the <see langword="MarshalDirectiveException" /> class with a specified error message.</summary>
+		/// <param name="message">The error message that specifies the reason for the exception.</param>
+		// Token: 0x06002CD5 RID: 11477 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CD5")]
+		[Address(RVA = "0x2CF0FA0", Offset = "0x2CEFFA0", VA = "0x182CF0FA0")]
+		public MarshalDirectiveException(string message)
+		{
+		}
+
+		/// <summary>Initializes a new instance of the <see langword="MarshalDirectiveException" /> class from serialization data.</summary>
+		/// <param name="info">The object that holds the serialized object data.</param>
+		/// <param name="context">The contextual information about the source or destination.</param>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="info" /> is <see langword="null" />.</exception>
+		// Token: 0x06002CD6 RID: 11478 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CD6")]
+		[Address(RVA = "0x7241B0", Offset = "0x7231B0", VA = "0x1807241B0")]
+		protected MarshalDirectiveException(SerializationInfo info, StreamingContext context)
+		{
+		}
+	}
+}

mscorlib/System/Runtime/InteropServices/OptionalAttribute.cs

@@ -0,0 +1,21 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Indicates that a parameter is optional.</summary>
+	// Token: 0x02000593 RID: 1427
+	[Token(Token = "0x2000593")]
+	[ComVisible(true)]
+	[AttributeUsage(AttributeTargets.Parameter)]
+	public sealed class OptionalAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see langword="OptionalAttribute" /> class with default values.</summary>
+		// Token: 0x06002CB5 RID: 11445 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CB5")]
+		[Address(RVA = "0x42BA20", Offset = "0x42AA20", VA = "0x18042BA20")]
+		public OptionalAttribute()
+		{
+		}
+	}
+}

mscorlib/System/Runtime/InteropServices/OutAttribute.cs

@@ -0,0 +1,21 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Indicates that data should be marshaled from callee back to caller.</summary>
+	// Token: 0x02000592 RID: 1426
+	[Token(Token = "0x2000592")]
+	[ComVisible(true)]
+	[AttributeUsage(AttributeTargets.Parameter)]
+	public sealed class OutAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.InteropServices.OutAttribute" /> class.</summary>
+		// Token: 0x06002CB4 RID: 11444 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CB4")]
+		[Address(RVA = "0x42BA20", Offset = "0x42AA20", VA = "0x18042BA20")]
+		public OutAttribute()
+		{
+		}
+	}
+}

mscorlib/System/Runtime/InteropServices/PreserveSigAttribute.cs

@@ -0,0 +1,21 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Indicates that the HRESULT or <see langword="retval" /> signature transformation that takes place during COM interop calls should be suppressed.</summary>
+	// Token: 0x02000590 RID: 1424
+	[Token(Token = "0x2000590")]
+	[AttributeUsage(AttributeTargets.Method)]
+	[ComVisible(true)]
+	public sealed class PreserveSigAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.InteropServices.PreserveSigAttribute" /> class.</summary>
+		// Token: 0x06002CB2 RID: 11442 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CB2")]
+		[Address(RVA = "0x42BA20", Offset = "0x42AA20", VA = "0x18042BA20")]
+		public PreserveSigAttribute()
+		{
+		}
+	}
+}

mscorlib/System/Runtime/InteropServices/SafeArrayTypeMismatchException.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Runtime.Serialization;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>The exception thrown when the type of the incoming <see langword="SAFEARRAY" /> does not match the type specified in the managed signature.</summary>
+	// Token: 0x020005A3 RID: 1443
+	[Token(Token = "0x20005A3")]
+	[ComVisible(true)]
+	[Serializable]
+	public class SafeArrayTypeMismatchException : SystemException
+	{
+		/// <summary>Initializes a new instance of the <see langword="SafeArrayTypeMismatchException" /> class with default values.</summary>
+		// Token: 0x06002CD7 RID: 11479 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CD7")]
+		[Address(RVA = "0x2CFC6F0", Offset = "0x2CFB6F0", VA = "0x182CFC6F0")]
+		public SafeArrayTypeMismatchException()
+		{
+		}
+
+		/// <summary>Initializes a new instance of the <see langword="SafeArrayTypeMismatchException" /> class from serialization data.</summary>
+		/// <param name="info">The object that holds the serialized object data.</param>
+		/// <param name="context">The contextual information about the source or destination.</param>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="info" /> is <see langword="null" />.</exception>
+		// Token: 0x06002CD8 RID: 11480 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CD8")]
+		[Address(RVA = "0x7241B0", Offset = "0x7231B0", VA = "0x1807241B0")]
+		protected SafeArrayTypeMismatchException(SerializationInfo info, StreamingContext context)
+		{
+		}
+	}
+}

mscorlib/System/Runtime/InteropServices/SafeBuffer.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Runtime.ConstrainedExecution;
+using Cpp2IlInjected;
+using Microsoft.Win32.SafeHandles;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Provides a controlled memory buffer that can be used for reading and writing. Attempts to access memory outside the controlled buffer (underruns and overruns) raise exceptions.</summary>
+	// Token: 0x020005A9 RID: 1449
+	[Token(Token = "0x20005A9")]
+	public abstract class SafeBuffer : SafeHandleZeroOrMinusOneIsInvalid
+	{
+		/// <summary>Obtains a pointer from a <see cref="T:System.Runtime.InteropServices.SafeBuffer" /> object for a block of memory.</summary>
+		/// <param name="pointer">A byte pointer, passed by reference, to receive the pointer from within the <see cref="T:System.Runtime.InteropServices.SafeBuffer" /> object. You must set this pointer to <see langword="null" /> before you call this method.</param>
+		/// <exception cref="T:System.InvalidOperationException">The <see cref="Overload:System.Runtime.InteropServices.SafeBuffer.Initialize" /> method has not been called.</exception>
+		// Token: 0x06002D4B RID: 11595 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002D4B")]
+		[Address(RVA = "0x2CFC750", Offset = "0x2CFB750", VA = "0x182CFC750")]
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
+		[CLSCompliant(false)]
+		public unsafe void AcquirePointer(ref byte* pointer)
+		{
+		}
+
+		/// <summary>Releases a pointer that was obtained by the <see cref="M:System.Runtime.InteropServices.SafeBuffer.AcquirePointer(System.Byte*@)" /> method.</summary>
+		/// <exception cref="T:System.InvalidOperationException">The <see cref="Overload:System.Runtime.InteropServices.SafeBuffer.Initialize" /> method has not been called.</exception>
+		// Token: 0x06002D4C RID: 11596 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002D4C")]
+		[Address(RVA = "0x2CFC7E0", Offset = "0x2CFB7E0", VA = "0x182CFC7E0")]
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
+		public void ReleasePointer()
+		{
+		}
+
+		// Token: 0x04001A10 RID: 6672
+		[FieldOffset(Offset = "0x20")]
+		[Token(Token = "0x4001A10")]
+		private bool inited;
+	}
+}

mscorlib/System/Runtime/InteropServices/SafeHandle.cs

@@ -0,0 +1,203 @@
+using System;
+using System.Runtime.ConstrainedExecution;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Represents a wrapper class for operating system handles. This class must be inherited.</summary>
+	// Token: 0x020005A4 RID: 1444
+	[Token(Token = "0x20005A4")]
+	[StructLayout(0)]
+	public abstract class SafeHandle : CriticalFinalizerObject, IDisposable
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.InteropServices.SafeHandle" /> class with the specified invalid handle value.</summary>
+		/// <param name="invalidHandleValue">The value of an invalid handle (usually 0 or -1).  Your implementation of <see cref="P:System.Runtime.InteropServices.SafeHandle.IsInvalid" /> should return <see langword="true" /> for this value.</param>
+		/// <param name="ownsHandle">
+		///   <see langword="true" /> to reliably let <see cref="T:System.Runtime.InteropServices.SafeHandle" /> release the handle during the finalization phase; otherwise, <see langword="false" /> (not recommended).</param>
+		/// <exception cref="T:System.TypeLoadException">The derived class resides in an assembly without unmanaged code access permission.</exception>
+		// Token: 0x06002CD9 RID: 11481 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CD9")]
+		[Address(RVA = "0x2CFCDC0", Offset = "0x2CFBDC0", VA = "0x182CFCDC0")]
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
+		protected SafeHandle(IntPtr invalidHandleValue, bool ownsHandle)
+		{
+		}
+
+		/// <summary>Frees all resources associated with the handle.</summary>
+		// Token: 0x06002CDA RID: 11482 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CDA")]
+		[Address(RVA = "0x2CFCBC0", Offset = "0x2CFBBC0", VA = "0x182CFCBC0", Slot = "1")]
+		protected override void Finalize()
+		{
+		}
+
+		/// <summary>Sets the handle to the specified pre-existing handle.</summary>
+		/// <param name="handle">The pre-existing handle to use.</param>
+		// Token: 0x06002CDB RID: 11483 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CDB")]
+		[Address(RVA = "0x415800", Offset = "0x414800", VA = "0x180415800")]
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
+		protected void SetHandle(IntPtr handle)
+		{
+		}
+
+		/// <summary>Returns the value of the <see cref="F:System.Runtime.InteropServices.SafeHandle.handle" /> field.</summary>
+		/// <returns>An <see langword="IntPtr" /> representing the value of the <see cref="F:System.Runtime.InteropServices.SafeHandle.handle" /> field. If the handle has been marked invalid with <see cref="M:System.Runtime.InteropServices.SafeHandle.SetHandleAsInvalid" />, this method still returns the original handle value, which can be a stale value.</returns>
+		// Token: 0x06002CDC RID: 11484 RVA: 0x00018E40 File Offset: 0x00017040
+		[Token(Token = "0x6002CDC")]
+		[Address(RVA = "0x411530", Offset = "0x410530", VA = "0x180411530")]
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
+		public IntPtr DangerousGetHandle()
+		{
+			return 0;
+		}
+
+		/// <summary>Gets a value indicating whether the handle is closed.</summary>
+		/// <returns>
+		///   <see langword="true" /> if the handle is closed; otherwise, <see langword="false" />.</returns>
+		// Token: 0x170006CB RID: 1739
+		// (get) Token: 0x06002CDD RID: 11485 RVA: 0x00018E58 File Offset: 0x00017058
+		[Token(Token = "0x170006CB")]
+		public bool IsClosed
+		{
+			[Token(Token = "0x6002CDD")]
+			[Address(RVA = "0x2CFCE50", Offset = "0x2CFBE50", VA = "0x182CFCE50")]
+			[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
+			get
+			{
+				return default(bool);
+			}
+		}
+
+		/// <summary>When overridden in a derived class, gets a value indicating whether the handle value is invalid.</summary>
+		/// <returns>
+		///   <see langword="true" /> if the handle value is invalid; otherwise, <see langword="false" />.</returns>
+		// Token: 0x170006CC RID: 1740
+		// (get) Token: 0x06002CDE RID: 11486
+		[Token(Token = "0x170006CC")]
+		public abstract bool IsInvalid
+		{
+			[Token(Token = "0x6002CDE")]
+			[Address(Slot = "5")]
+			[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
+			get;
+		}
+
+		/// <summary>Marks the handle for releasing and freeing resources.</summary>
+		// Token: 0x06002CDF RID: 11487 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CDF")]
+		[Address(RVA = "0x2BA3AB0", Offset = "0x2BA2AB0", VA = "0x182BA3AB0")]
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
+		public void Close()
+		{
+		}
+
+		/// <summary>Releases all resources used by the <see cref="T:System.Runtime.InteropServices.SafeHandle" /> class.</summary>
+		// Token: 0x06002CE0 RID: 11488 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CE0")]
+		[Address(RVA = "0x2BA3AB0", Offset = "0x2BA2AB0", VA = "0x182BA3AB0", Slot = "4")]
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
+		public void Dispose()
+		{
+		}
+
+		/// <summary>Releases the unmanaged resources used by the <see cref="T:System.Runtime.InteropServices.SafeHandle" /> class specifying whether to perform a normal dispose operation.</summary>
+		/// <param name="disposing">
+		///   <see langword="true" /> for a normal dispose operation; <see langword="false" /> to finalize the handle.</param>
+		// Token: 0x06002CE1 RID: 11489 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CE1")]
+		[Address(RVA = "0x2CFCB10", Offset = "0x2CFBB10", VA = "0x182CFCB10", Slot = "6")]
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
+		protected virtual void Dispose(bool disposing)
+		{
+		}
+
+		/// <summary>When overridden in a derived class, executes the code required to free the handle.</summary>
+		/// <returns>
+		///   <see langword="true" /> if the handle is released successfully; otherwise, in the event of a catastrophic failure, <see langword="false" />. In this case, it generates a releaseHandleFailed Managed Debugging Assistant.</returns>
+		// Token: 0x06002CE2 RID: 11490
+		[Token(Token = "0x6002CE2")]
+		[Address(Slot = "7")]
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
+		protected abstract bool ReleaseHandle();
+
+		/// <summary>Marks a handle as no longer used.</summary>
+		// Token: 0x06002CE3 RID: 11491 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CE3")]
+		[Address(RVA = "0x2CFCCF0", Offset = "0x2CFBCF0", VA = "0x182CFCCF0")]
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
+		public void SetHandleAsInvalid()
+		{
+		}
+
+		/// <summary>Manually increments the reference counter on <see cref="T:System.Runtime.InteropServices.SafeHandle" /> instances.</summary>
+		/// <param name="success">
+		///   <see langword="true" /> if the reference counter was successfully incremented; otherwise, <see langword="false" />.</param>
+		// Token: 0x06002CE4 RID: 11492 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CE4")]
+		[Address(RVA = "0x2CFC850", Offset = "0x2CFB850", VA = "0x182CFC850")]
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
+		public void DangerousAddRef(ref bool success)
+		{
+		}
+
+		/// <summary>Manually decrements the reference counter on a <see cref="T:System.Runtime.InteropServices.SafeHandle" /> instance.</summary>
+		// Token: 0x06002CE5 RID: 11493 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CE5")]
+		[Address(RVA = "0x2CFCB00", Offset = "0x2CFBB00", VA = "0x182CFCB00")]
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
+		public void DangerousRelease()
+		{
+		}
+
+		// Token: 0x06002CE6 RID: 11494 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CE6")]
+		[Address(RVA = "0x2CFCC40", Offset = "0x2CFBC40", VA = "0x182CFCC40")]
+		private void InternalDispose()
+		{
+		}
+
+		// Token: 0x06002CE7 RID: 11495 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CE7")]
+		[Address(RVA = "0x2CFCCD0", Offset = "0x2CFBCD0", VA = "0x182CFCCD0")]
+		private void InternalFinalize()
+		{
+		}
+
+		// Token: 0x06002CE8 RID: 11496 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CE8")]
+		[Address(RVA = "0x2CFC960", Offset = "0x2CFB960", VA = "0x182CFC960")]
+		private void DangerousReleaseInternal(bool dispose)
+		{
+		}
+
+		/// <summary>Specifies the handle to be wrapped.</summary>
+		// Token: 0x040019F8 RID: 6648
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x40019F8")]
+		protected IntPtr handle;
+
+		// Token: 0x040019F9 RID: 6649
+		[FieldOffset(Offset = "0x18")]
+		[Token(Token = "0x40019F9")]
+		private int _state;
+
+		// Token: 0x040019FA RID: 6650
+		[FieldOffset(Offset = "0x1C")]
+		[Token(Token = "0x40019FA")]
+		private bool _ownsHandle;
+
+		// Token: 0x040019FB RID: 6651
+		[FieldOffset(Offset = "0x1D")]
+		[Token(Token = "0x40019FB")]
+		private bool _fullyInitialized;
+
+		// Token: 0x040019FC RID: 6652
+		[Token(Token = "0x40019FC")]
+		private const int RefCount_Mask = 2147483644;
+
+		// Token: 0x040019FD RID: 6653
+		[Token(Token = "0x40019FD")]
+		private const int RefCount_One = 4;
+	}
+}

mscorlib/System/Runtime/InteropServices/UnmanagedFunctionPointerAttribute.cs

@@ -0,0 +1,51 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Controls the marshaling behavior of a delegate signature passed as an unmanaged function pointer to or from unmanaged code. This class cannot be inherited.</summary>
+	// Token: 0x02000584 RID: 1412
+	[Token(Token = "0x2000584")]
+	[AttributeUsage(AttributeTargets.Delegate)]
+	[ComVisible(true)]
+	public sealed class UnmanagedFunctionPointerAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.InteropServices.UnmanagedFunctionPointerAttribute" /> class with the specified calling convention.</summary>
+		/// <param name="callingConvention">The specified calling convention.</param>
+		// Token: 0x06002CA9 RID: 11433 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002CA9")]
+		[Address(RVA = "0x41F8E0", Offset = "0x41E8E0", VA = "0x18041F8E0")]
+		public UnmanagedFunctionPointerAttribute(CallingConvention callingConvention)
+		{
+		}
+
+		// Token: 0x0400196B RID: 6507
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x400196B")]
+		private CallingConvention m_callingConvention;
+
+		/// <summary>Indicates how to marshal string parameters to the method, and controls name mangling.</summary>
+		// Token: 0x0400196C RID: 6508
+		[FieldOffset(Offset = "0x14")]
+		[Token(Token = "0x400196C")]
+		public CharSet CharSet;
+
+		/// <summary>Enables or disables best-fit mapping behavior when converting Unicode characters to ANSI characters.</summary>
+		// Token: 0x0400196D RID: 6509
+		[FieldOffset(Offset = "0x18")]
+		[Token(Token = "0x400196D")]
+		public bool BestFitMapping;
+
+		/// <summary>Enables or disables the throwing of an exception on an unmappable Unicode character that is converted to an ANSI "?" character.</summary>
+		// Token: 0x0400196E RID: 6510
+		[FieldOffset(Offset = "0x19")]
+		[Token(Token = "0x400196E")]
+		public bool ThrowOnUnmappableChar;
+
+		/// <summary>Indicates whether the callee calls the <see langword="SetLastError" /> Win32 API function before returning from the attributed method.</summary>
+		// Token: 0x0400196F RID: 6511
+		[FieldOffset(Offset = "0x1A")]
+		[Token(Token = "0x400196F")]
+		public bool SetLastError;
+	}
+}

mscorlib/System/Runtime/InteropServices/UnmanagedType.cs

@@ -0,0 +1,169 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Identifies how to marshal parameters or fields to unmanaged code.</summary>
+	// Token: 0x0200058D RID: 1421
+	[Token(Token = "0x200058D")]
+	[ComVisible(true)]
+	[Serializable]
+	public enum UnmanagedType
+	{
+		/// <summary>A 4-byte Boolean value (<see langword="true" /> != 0, <see langword="false" /> = 0). This is the Win32 BOOL type.</summary>
+		// Token: 0x040019AC RID: 6572
+		[Token(Token = "0x40019AC")]
+		Bool = 2,
+		/// <summary>A 1-byte signed integer. You can use this member to transform a Boolean value into a 1-byte, C-style <see langword="bool" /> (<see langword="true" /> = 1, <see langword="false" /> = 0).</summary>
+		// Token: 0x040019AD RID: 6573
+		[Token(Token = "0x40019AD")]
+		I1,
+		/// <summary>A 1-byte unsigned integer.</summary>
+		// Token: 0x040019AE RID: 6574
+		[Token(Token = "0x40019AE")]
+		U1,
+		/// <summary>A 2-byte signed integer.</summary>
+		// Token: 0x040019AF RID: 6575
+		[Token(Token = "0x40019AF")]
+		I2,
+		/// <summary>A 2-byte unsigned integer.</summary>
+		// Token: 0x040019B0 RID: 6576
+		[Token(Token = "0x40019B0")]
+		U2,
+		/// <summary>A 4-byte signed integer.</summary>
+		// Token: 0x040019B1 RID: 6577
+		[Token(Token = "0x40019B1")]
+		I4,
+		/// <summary>A 4-byte unsigned integer.</summary>
+		// Token: 0x040019B2 RID: 6578
+		[Token(Token = "0x40019B2")]
+		U4,
+		/// <summary>An 8-byte signed integer.</summary>
+		// Token: 0x040019B3 RID: 6579
+		[Token(Token = "0x40019B3")]
+		I8,
+		/// <summary>An 8-byte unsigned integer.</summary>
+		// Token: 0x040019B4 RID: 6580
+		[Token(Token = "0x40019B4")]
+		U8,
+		/// <summary>A 4-byte floating-point number.</summary>
+		// Token: 0x040019B5 RID: 6581
+		[Token(Token = "0x40019B5")]
+		R4,
+		/// <summary>An 8-byte floating-point number.</summary>
+		// Token: 0x040019B6 RID: 6582
+		[Token(Token = "0x40019B6")]
+		R8,
+		/// <summary>A currency type. Used on a <see cref="T:System.Decimal" /> to marshal the decimal value as a COM currency type instead of as a <see langword="Decimal" />.</summary>
+		// Token: 0x040019B7 RID: 6583
+		[Token(Token = "0x40019B7")]
+		Currency = 15,
+		/// <summary>A Unicode character string that is a length-prefixed double byte. You can use this member, which is the default string in COM, on the <see cref="T:System.String" /> data type.</summary>
+		// Token: 0x040019B8 RID: 6584
+		[Token(Token = "0x40019B8")]
+		BStr = 19,
+		/// <summary>A single byte, null-terminated ANSI character string. You can use this member on the <see cref="T:System.String" /> and <see cref="T:System.Text.StringBuilder" /> data types.</summary>
+		// Token: 0x040019B9 RID: 6585
+		[Token(Token = "0x40019B9")]
+		LPStr,
+		/// <summary>A 2-byte, null-terminated Unicode character string.</summary>
+		// Token: 0x040019BA RID: 6586
+		[Token(Token = "0x40019BA")]
+		LPWStr,
+		/// <summary>A platform-dependent character string: ANSI on Windows 98, and Unicode on Windows NT and Windows XP. This value is supported only for platform invoke and not for COM interop, because exporting a string of type <see langword="LPTStr" /> is not supported.</summary>
+		// Token: 0x040019BB RID: 6587
+		[Token(Token = "0x40019BB")]
+		LPTStr,
+		/// <summary>Used for in-line, fixed-length character arrays that appear within a structure. The character type used with <see cref="F:System.Runtime.InteropServices.UnmanagedType.ByValTStr" /> is determined by the <see cref="T:System.Runtime.InteropServices.CharSet" /> argument of the <see cref="T:System.Runtime.InteropServices.StructLayoutAttribute" /> attribute applied to the containing structure. Always use the <see cref="F:System.Runtime.InteropServices.MarshalAsAttribute.SizeConst" /> field to indicate the size of the array.</summary>
+		// Token: 0x040019BC RID: 6588
+		[Token(Token = "0x40019BC")]
+		ByValTStr,
+		/// <summary>A COM <see langword="IUnknown" /> pointer. You can use this member on the <see cref="T:System.Object" /> data type.</summary>
+		// Token: 0x040019BD RID: 6589
+		[Token(Token = "0x40019BD")]
+		IUnknown = 25,
+		/// <summary>A COM <see langword="IDispatch" /> pointer (<see langword="Object" /> in Microsoft Visual Basic 6.0).</summary>
+		// Token: 0x040019BE RID: 6590
+		[Token(Token = "0x40019BE")]
+		IDispatch,
+		/// <summary>A VARIANT, which is used to marshal managed formatted classes and value types.</summary>
+		// Token: 0x040019BF RID: 6591
+		[Token(Token = "0x40019BF")]
+		Struct,
+		/// <summary>A COM interface pointer. The <see cref="T:System.Guid" /> of the interface is obtained from the class metadata. Use this member to specify the exact interface type or the default interface type if you apply it to a class. This member produces the same behavior as <see cref="F:System.Runtime.InteropServices.UnmanagedType.IUnknown" /> when you apply it to the <see cref="T:System.Object" /> data type.</summary>
+		// Token: 0x040019C0 RID: 6592
+		[Token(Token = "0x40019C0")]
+		Interface,
+		/// <summary>A <see langword="SafeArray" />, which is a self-describing array that carries the type, rank, and bounds of the associated array data. You can use this member with the <see cref="F:System.Runtime.InteropServices.MarshalAsAttribute.SafeArraySubType" /> field to override the default element type.</summary>
+		// Token: 0x040019C1 RID: 6593
+		[Token(Token = "0x40019C1")]
+		SafeArray,
+		/// <summary>When the <see cref="P:System.Runtime.InteropServices.MarshalAsAttribute.Value" /> property is set to <see langword="ByValArray" />, the <see cref="F:System.Runtime.InteropServices.MarshalAsAttribute.SizeConst" /> field must be set to indicate the number of elements in the array. The <see cref="F:System.Runtime.InteropServices.MarshalAsAttribute.ArraySubType" /> field can optionally contain the <see cref="T:System.Runtime.InteropServices.UnmanagedType" /> of the array elements when it is necessary to differentiate among string types. You can use this <see cref="T:System.Runtime.InteropServices.UnmanagedType" /> only on an array that whose elements appear as fields in a structure.</summary>
+		// Token: 0x040019C2 RID: 6594
+		[Token(Token = "0x40019C2")]
+		ByValArray,
+		/// <summary>A platform-dependent, signed integer: 4 bytes on 32-bit Windows, 8 bytes on 64-bit Windows.</summary>
+		// Token: 0x040019C3 RID: 6595
+		[Token(Token = "0x40019C3")]
+		SysInt,
+		/// <summary>A platform-dependent, unsigned integer: 4 bytes on 32-bit Windows, 8 bytes on 64-bit Windows.</summary>
+		// Token: 0x040019C4 RID: 6596
+		[Token(Token = "0x40019C4")]
+		SysUInt,
+		/// <summary>A value that enables Visual Basic to change a string in unmanaged code and have the results reflected in managed code. This value is only supported for platform invoke.</summary>
+		// Token: 0x040019C5 RID: 6597
+		[Token(Token = "0x40019C5")]
+		VBByRefStr = 34,
+		/// <summary>An ANSI character string that is a length-prefixed single byte. You can use this member on the <see cref="T:System.String" /> data type.</summary>
+		// Token: 0x040019C6 RID: 6598
+		[Token(Token = "0x40019C6")]
+		AnsiBStr,
+		/// <summary>A length-prefixed, platform-dependent <see langword="char" /> string: ANSI on Windows 98, Unicode on Windows NT. You rarely use this BSTR-like member.</summary>
+		// Token: 0x040019C7 RID: 6599
+		[Token(Token = "0x40019C7")]
+		TBStr,
+		/// <summary>A 2-byte, OLE-defined VARIANT_BOOL type (<see langword="true" /> = -1, <see langword="false" /> = 0).</summary>
+		// Token: 0x040019C8 RID: 6600
+		[Token(Token = "0x40019C8")]
+		VariantBool,
+		/// <summary>An integer that can be used as a C-style function pointer. You can use this member on a <see cref="T:System.Delegate" /> data type or on a type that inherits from a <see cref="T:System.Delegate" />.</summary>
+		// Token: 0x040019C9 RID: 6601
+		[Token(Token = "0x40019C9")]
+		FunctionPtr,
+		/// <summary>A dynamic type that determines the type of an object at run time and marshals the object as that type. This member is valid for platform invoke methods only.</summary>
+		// Token: 0x040019CA RID: 6602
+		[Token(Token = "0x40019CA")]
+		AsAny = 40,
+		/// <summary>A pointer to the first element of a C-style array. When marshaling from managed to unmanaged code, the length of the array is determined by the length of the managed array. When marshaling from unmanaged to managed code, the length of the array is determined from the <see cref="F:System.Runtime.InteropServices.MarshalAsAttribute.SizeConst" /> and <see cref="F:System.Runtime.InteropServices.MarshalAsAttribute.SizeParamIndex" /> fields, optionally followed by the unmanaged type of the elements within the array when it is necessary to differentiate among string types.</summary>
+		// Token: 0x040019CB RID: 6603
+		[Token(Token = "0x40019CB")]
+		LPArray = 42,
+		/// <summary>A pointer to a C-style structure that you use to marshal managed formatted classes. This member is valid for platform invoke methods only.</summary>
+		// Token: 0x040019CC RID: 6604
+		[Token(Token = "0x40019CC")]
+		LPStruct,
+		/// <summary>Specifies the custom marshaler class when used with the <see cref="F:System.Runtime.InteropServices.MarshalAsAttribute.MarshalType" /> or <see cref="F:System.Runtime.InteropServices.MarshalAsAttribute.MarshalTypeRef" /> field. The <see cref="F:System.Runtime.InteropServices.MarshalAsAttribute.MarshalCookie" /> field can be used to pass additional information to the custom marshaler. You can use this member on any reference type. This member is valid for parameters and return values only. It cannot be used on fields.</summary>
+		// Token: 0x040019CD RID: 6605
+		[Token(Token = "0x40019CD")]
+		CustomMarshaler,
+		/// <summary>A native type that is associated with an <see cref="F:System.Runtime.InteropServices.UnmanagedType.I4" /> or an <see cref="F:System.Runtime.InteropServices.UnmanagedType.U4" /> and that causes the parameter to be exported as an HRESULT in the exported type library.</summary>
+		// Token: 0x040019CE RID: 6606
+		[Token(Token = "0x40019CE")]
+		Error,
+		/// <summary>A Windows Runtime interface pointer. You can use this member on the <see cref="T:System.Object" /> data type.</summary>
+		// Token: 0x040019CF RID: 6607
+		[Token(Token = "0x40019CF")]
+		[ComVisible(false)]
+		IInspectable,
+		/// <summary>A Windows Runtime string. You can use this member on the <see cref="T:System.String" /> data type.</summary>
+		// Token: 0x040019D0 RID: 6608
+		[Token(Token = "0x40019D0")]
+		[ComVisible(false)]
+		HString,
+		/// <summary>A pointer to a UTF-8 encoded string.</summary>
+		// Token: 0x040019D1 RID: 6609
+		[Token(Token = "0x40019D1")]
+		[ComVisible(false)]
+		LPUTF8Str
+	}
+}

mscorlib/System/Runtime/InteropServices/VarEnum.cs

@@ -0,0 +1,190 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Indicates how to marshal the array elements when an array is marshaled from managed to unmanaged code as a <see cref="F:System.Runtime.InteropServices.UnmanagedType.SafeArray" />.</summary>
+	// Token: 0x0200058C RID: 1420
+	[Token(Token = "0x200058C")]
+	[ComVisible(true)]
+	[Serializable]
+	public enum VarEnum
+	{
+		/// <summary>Indicates that a value was not specified.</summary>
+		// Token: 0x0400197F RID: 6527
+		[Token(Token = "0x400197F")]
+		VT_EMPTY,
+		/// <summary>Indicates a null value, similar to a null value in SQL.</summary>
+		// Token: 0x04001980 RID: 6528
+		[Token(Token = "0x4001980")]
+		VT_NULL,
+		/// <summary>Indicates a <see langword="short" /> integer.</summary>
+		// Token: 0x04001981 RID: 6529
+		[Token(Token = "0x4001981")]
+		VT_I2,
+		/// <summary>Indicates a <see langword="long" /> integer.</summary>
+		// Token: 0x04001982 RID: 6530
+		[Token(Token = "0x4001982")]
+		VT_I4,
+		/// <summary>Indicates a <see langword="float" /> value.</summary>
+		// Token: 0x04001983 RID: 6531
+		[Token(Token = "0x4001983")]
+		VT_R4,
+		/// <summary>Indicates a <see langword="double" /> value.</summary>
+		// Token: 0x04001984 RID: 6532
+		[Token(Token = "0x4001984")]
+		VT_R8,
+		/// <summary>Indicates a currency value.</summary>
+		// Token: 0x04001985 RID: 6533
+		[Token(Token = "0x4001985")]
+		VT_CY,
+		/// <summary>Indicates a DATE value.</summary>
+		// Token: 0x04001986 RID: 6534
+		[Token(Token = "0x4001986")]
+		VT_DATE,
+		/// <summary>Indicates a BSTR string.</summary>
+		// Token: 0x04001987 RID: 6535
+		[Token(Token = "0x4001987")]
+		VT_BSTR,
+		/// <summary>Indicates an <see langword="IDispatch" /> pointer.</summary>
+		// Token: 0x04001988 RID: 6536
+		[Token(Token = "0x4001988")]
+		VT_DISPATCH,
+		/// <summary>Indicates an SCODE.</summary>
+		// Token: 0x04001989 RID: 6537
+		[Token(Token = "0x4001989")]
+		VT_ERROR,
+		/// <summary>Indicates a Boolean value.</summary>
+		// Token: 0x0400198A RID: 6538
+		[Token(Token = "0x400198A")]
+		VT_BOOL,
+		/// <summary>Indicates a VARIANT <see langword="far" /> pointer.</summary>
+		// Token: 0x0400198B RID: 6539
+		[Token(Token = "0x400198B")]
+		VT_VARIANT,
+		/// <summary>Indicates an <see langword="IUnknown" /> pointer.</summary>
+		// Token: 0x0400198C RID: 6540
+		[Token(Token = "0x400198C")]
+		VT_UNKNOWN,
+		/// <summary>Indicates a <see langword="decimal" /> value.</summary>
+		// Token: 0x0400198D RID: 6541
+		[Token(Token = "0x400198D")]
+		VT_DECIMAL,
+		/// <summary>Indicates a <see langword="char" /> value.</summary>
+		// Token: 0x0400198E RID: 6542
+		[Token(Token = "0x400198E")]
+		VT_I1 = 16,
+		/// <summary>Indicates a <see langword="byte" />.</summary>
+		// Token: 0x0400198F RID: 6543
+		[Token(Token = "0x400198F")]
+		VT_UI1,
+		/// <summary>Indicates an <see langword="unsigned" /><see langword="short" />.</summary>
+		// Token: 0x04001990 RID: 6544
+		[Token(Token = "0x4001990")]
+		VT_UI2,
+		/// <summary>Indicates an <see langword="unsigned" /><see langword="long" />.</summary>
+		// Token: 0x04001991 RID: 6545
+		[Token(Token = "0x4001991")]
+		VT_UI4,
+		/// <summary>Indicates a 64-bit integer.</summary>
+		// Token: 0x04001992 RID: 6546
+		[Token(Token = "0x4001992")]
+		VT_I8,
+		/// <summary>Indicates an 64-bit unsigned integer.</summary>
+		// Token: 0x04001993 RID: 6547
+		[Token(Token = "0x4001993")]
+		VT_UI8,
+		/// <summary>Indicates an integer value.</summary>
+		// Token: 0x04001994 RID: 6548
+		[Token(Token = "0x4001994")]
+		VT_INT,
+		/// <summary>Indicates an <see langword="unsigned" /> integer value.</summary>
+		// Token: 0x04001995 RID: 6549
+		[Token(Token = "0x4001995")]
+		VT_UINT,
+		/// <summary>Indicates a C style <see langword="void" />.</summary>
+		// Token: 0x04001996 RID: 6550
+		[Token(Token = "0x4001996")]
+		VT_VOID,
+		/// <summary>Indicates an HRESULT.</summary>
+		// Token: 0x04001997 RID: 6551
+		[Token(Token = "0x4001997")]
+		VT_HRESULT,
+		/// <summary>Indicates a pointer type.</summary>
+		// Token: 0x04001998 RID: 6552
+		[Token(Token = "0x4001998")]
+		VT_PTR,
+		/// <summary>Indicates a SAFEARRAY. Not valid in a VARIANT.</summary>
+		// Token: 0x04001999 RID: 6553
+		[Token(Token = "0x4001999")]
+		VT_SAFEARRAY,
+		/// <summary>Indicates a C style array.</summary>
+		// Token: 0x0400199A RID: 6554
+		[Token(Token = "0x400199A")]
+		VT_CARRAY,
+		/// <summary>Indicates a user defined type.</summary>
+		// Token: 0x0400199B RID: 6555
+		[Token(Token = "0x400199B")]
+		VT_USERDEFINED,
+		/// <summary>Indicates a null-terminated string.</summary>
+		// Token: 0x0400199C RID: 6556
+		[Token(Token = "0x400199C")]
+		VT_LPSTR,
+		/// <summary>Indicates a wide string terminated by <see langword="null" />.</summary>
+		// Token: 0x0400199D RID: 6557
+		[Token(Token = "0x400199D")]
+		VT_LPWSTR,
+		/// <summary>Indicates a user defined type.</summary>
+		// Token: 0x0400199E RID: 6558
+		[Token(Token = "0x400199E")]
+		VT_RECORD = 36,
+		/// <summary>Indicates a FILETIME value.</summary>
+		// Token: 0x0400199F RID: 6559
+		[Token(Token = "0x400199F")]
+		VT_FILETIME = 64,
+		/// <summary>Indicates length prefixed bytes.</summary>
+		// Token: 0x040019A0 RID: 6560
+		[Token(Token = "0x40019A0")]
+		VT_BLOB,
+		/// <summary>Indicates that the name of a stream follows.</summary>
+		// Token: 0x040019A1 RID: 6561
+		[Token(Token = "0x40019A1")]
+		VT_STREAM,
+		/// <summary>Indicates that the name of a storage follows.</summary>
+		// Token: 0x040019A2 RID: 6562
+		[Token(Token = "0x40019A2")]
+		VT_STORAGE,
+		/// <summary>Indicates that a stream contains an object.</summary>
+		// Token: 0x040019A3 RID: 6563
+		[Token(Token = "0x40019A3")]
+		VT_STREAMED_OBJECT,
+		/// <summary>Indicates that a storage contains an object.</summary>
+		// Token: 0x040019A4 RID: 6564
+		[Token(Token = "0x40019A4")]
+		VT_STORED_OBJECT,
+		/// <summary>Indicates that a blob contains an object.</summary>
+		// Token: 0x040019A5 RID: 6565
+		[Token(Token = "0x40019A5")]
+		VT_BLOB_OBJECT,
+		/// <summary>Indicates the clipboard format.</summary>
+		// Token: 0x040019A6 RID: 6566
+		[Token(Token = "0x40019A6")]
+		VT_CF,
+		/// <summary>Indicates a class ID.</summary>
+		// Token: 0x040019A7 RID: 6567
+		[Token(Token = "0x40019A7")]
+		VT_CLSID,
+		/// <summary>Indicates a simple, counted array.</summary>
+		// Token: 0x040019A8 RID: 6568
+		[Token(Token = "0x40019A8")]
+		VT_VECTOR = 4096,
+		/// <summary>Indicates a <see langword="SAFEARRAY" /> pointer.</summary>
+		// Token: 0x040019A9 RID: 6569
+		[Token(Token = "0x40019A9")]
+		VT_ARRAY = 8192,
+		/// <summary>Indicates that a value is a reference.</summary>
+		// Token: 0x040019AA RID: 6570
+		[Token(Token = "0x40019AA")]
+		VT_BYREF = 16384
+	}
+}

mscorlib/System/Runtime/InteropServices/_Activator.cs

@@ -0,0 +1,16 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Exposes the <see cref="T:System.Activator" /> class to unmanaged code.</summary>
+	// Token: 0x020005AA RID: 1450
+	[Token(Token = "0x20005AA")]
+	[CLSCompliant(false)]
+	[Guid("03973551-57A1-3900-A2B5-9083E3FF2943")]
+	[ComVisible(true)]
+	[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+	public interface _Activator
+	{
+	}
+}

mscorlib/System/Runtime/InteropServices/_Assembly.cs

@@ -0,0 +1,16 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Exposes the public members of the <see cref="T:System.Reflection.Assembly" /> class to unmanaged code.</summary>
+	// Token: 0x020005AB RID: 1451
+	[Token(Token = "0x20005AB")]
+	[CLSCompliant(false)]
+	[Guid("17156360-2F1A-384A-BC52-FDE93C215C5B")]
+	[ComVisible(true)]
+	[InterfaceType(ComInterfaceType.InterfaceIsDual)]
+	public interface _Assembly
+	{
+	}
+}

mscorlib/System/Runtime/InteropServices/_AssemblyName.cs

@@ -0,0 +1,16 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Exposes the <see cref="T:System.Reflection.AssemblyName" /> class to unmanaged code.</summary>
+	// Token: 0x020005AC RID: 1452
+	[Token(Token = "0x20005AC")]
+	[CLSCompliant(false)]
+	[Guid("B42B6AAC-317E-34D5-9FA9-093BB4160C50")]
+	[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+	[ComVisible(true)]
+	public interface _AssemblyName
+	{
+	}
+}