oh dear

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: 0x02000537 RID: 1335
+	[Token(Token = "0x2000537")]
+	internal struct AsyncMethodBuilderCore
+	{
+		// Token: 0x06002A1A RID: 10778 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A1A")]
+		[Address(RVA = "0x294B360", Offset = "0x294A160", VA = "0x18294B360")]
+		public void SetStateMachine(IAsyncStateMachine stateMachine)
+		{
+		}
+
+		// Token: 0x06002A1B RID: 10779 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002A1B")]
+		[Address(RVA = "0x294AE90", Offset = "0x2949C90", VA = "0x18294AE90")]
+		internal Action GetCompletionAction(Task taskForTracing, ref AsyncMethodBuilderCore.MoveNextRunner runnerToInitialize)
+		{
+			return null;
+		}
+
+		// Token: 0x06002A1C RID: 10780 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002A1C")]
+		[Address(RVA = "0x294B030", Offset = "0x2949E30", VA = "0x18294B030")]
+		private Action OutputAsyncCausalityEvents(Task innerTask, Action continuation)
+		{
+			return null;
+		}
+
+		// Token: 0x06002A1D RID: 10781 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A1D")]
+		[Address(RVA = "0x294B1B0", Offset = "0x2949FB0", VA = "0x18294B1B0")]
+		internal void PostBoxInitialization(IAsyncStateMachine stateMachine, AsyncMethodBuilderCore.MoveNextRunner runner, Task builtTask)
+		{
+		}
+
+		// Token: 0x06002A1E RID: 10782 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A1E")]
+		[Address(RVA = "0x294B420", Offset = "0x294A220", VA = "0x18294B420")]
+		internal static void ThrowAsync(Exception exception, SynchronizationContext targetContext)
+		{
+		}
+
+		// Token: 0x06002A1F RID: 10783 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002A1F")]
+		[Address(RVA = "0x294AD80", Offset = "0x2949B80", VA = "0x18294AD80")]
+		internal static Action CreateContinuationWrapper(Action continuation, Action invokeAction, [Optional] Task innerTask)
+		{
+			return null;
+		}
+
+		// Token: 0x06002A20 RID: 10784 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002A20")]
+		[Address(RVA = "0x294B690", Offset = "0x294A490", VA = "0x18294B690")]
+		internal static Task TryGetContinuationTask(Action action)
+		{
+			return null;
+		}
+
+		// Token: 0x04001873 RID: 6259
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x4001873")]
+		internal IAsyncStateMachine m_stateMachine;
+
+		// Token: 0x04001874 RID: 6260
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x8")]
+		[Token(Token = "0x4001874")]
+		internal Action m_defaultContextAction;
+
+		// Token: 0x02000538 RID: 1336
+		[Token(Token = "0x2000538")]
+		internal sealed class MoveNextRunner
+		{
+			// Token: 0x06002A21 RID: 10785 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6002A21")]
+			[Address(RVA = "0x4089A0", Offset = "0x4077A0", VA = "0x1804089A0")]
+			internal MoveNextRunner(ExecutionContext context, IAsyncStateMachine stateMachine)
+			{
+			}
+
+			// Token: 0x06002A22 RID: 10786 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6002A22")]
+			[Address(RVA = "0x2953B60", Offset = "0x2952960", VA = "0x182953B60")]
+			internal void Run()
+			{
+			}
+
+			// Token: 0x06002A23 RID: 10787 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6002A23")]
+			[Address(RVA = "0x2953AC0", Offset = "0x29528C0", VA = "0x182953AC0")]
+			private static void InvokeMoveNext(object stateMachine)
+			{
+			}
+
+			// Token: 0x04001875 RID: 6261
+			[global::Cpp2IlInjected.FieldOffset(Offset = "0x10")]
+			[Token(Token = "0x4001875")]
+			private readonly ExecutionContext m_context;
+
+			// Token: 0x04001876 RID: 6262
+			[global::Cpp2IlInjected.FieldOffset(Offset = "0x18")]
+			[Token(Token = "0x4001876")]
+			internal IAsyncStateMachine m_stateMachine;
+
+			// Token: 0x04001877 RID: 6263
+			[Token(Token = "0x4001877")]
+			private static ContextCallback s_invokeMoveNext;
+		}
+
+		// Token: 0x02000539 RID: 1337
+		[Token(Token = "0x2000539")]
+		private class ContinuationWrapper
+		{
+			// Token: 0x06002A24 RID: 10788 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6002A24")]
+			[Address(RVA = "0x294C0A0", Offset = "0x294AEA0", VA = "0x18294C0A0")]
+			internal ContinuationWrapper(Action continuation, Action invokeAction, Task innerTask)
+			{
+			}
+
+			// Token: 0x06002A25 RID: 10789 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6002A25")]
+			[Address(RVA = "0x1992280", Offset = "0x1991080", VA = "0x181992280")]
+			internal void Invoke()
+			{
+			}
+
+			// Token: 0x04001878 RID: 6264
+			[global::Cpp2IlInjected.FieldOffset(Offset = "0x10")]
+			[Token(Token = "0x4001878")]
+			internal readonly Action m_continuation;
+
+			// Token: 0x04001879 RID: 6265
+			[global::Cpp2IlInjected.FieldOffset(Offset = "0x18")]
+			[Token(Token = "0x4001879")]
+			private readonly Action m_invokeAction;
+
+			// Token: 0x0400187A RID: 6266
+			[global::Cpp2IlInjected.FieldOffset(Offset = "0x20")]
+			[Token(Token = "0x400187A")]
+			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: 0x0200053C RID: 1340
+	[Token(Token = "0x200053C")]
+	[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: 0x06002A2C RID: 10796 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A2C")]
+		[Address(RVA = "0x462000", Offset = "0x460E00", VA = "0x180462000")]
+		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: 0x02000536 RID: 1334
+	[Token(Token = "0x2000536")]
+	internal static class AsyncTaskCache
+	{
+		// Token: 0x06002A17 RID: 10775 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002A17")]
+		[Address(RVA = "0x294B720", Offset = "0x294A520", VA = "0x18294B720")]
+		private static Task<int>[] CreateInt32Tasks()
+		{
+			return null;
+		}
+
+		// Token: 0x06002A18 RID: 10776 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002A18")]
+		[Address(RVA = "0x1B4AFB0", Offset = "0x1B49DB0", VA = "0x181B4AFB0")]
+		internal static Task<TResult> CreateCacheableTask<TResult>(TResult result)
+		{
+			return null;
+		}
+
+		// Token: 0x04001870 RID: 6256
+		[Token(Token = "0x4001870")]
+		internal static readonly Task<bool> TrueTask;
+
+		// Token: 0x04001871 RID: 6257
+		[Token(Token = "0x4001871")]
+		internal static readonly Task<bool> FalseTask;
+
+		// Token: 0x04001872 RID: 6258
+		[Token(Token = "0x4001872")]
+		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: 0x02000535 RID: 1333
+	[Token(Token = "0x2000535")]
+	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: 0x06002A0C RID: 10764 RVA: 0x00016800 File Offset: 0x00014A00
+		[Token(Token = "0x6002A0C")]
+		[Address(RVA = "0x147A860", Offset = "0x1479660", VA = "0x18147A860")]
+		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: 0x06002A0D RID: 10765 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A0D")]
+		[Address(RVA = "0x20BA4E0", Offset = "0x20B92E0", VA = "0x1820BA4E0")]
+		[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: 0x06002A0E RID: 10766 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A0E")]
+		[Address(RVA = "0x2E99AD0", Offset = "0x2E988D0", VA = "0x182E99AD0")]
+		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: 0x06002A0F RID: 10767 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A0F")]
+		[Address(RVA = "0x20AD560", Offset = "0x20AC360", VA = "0x1820AD560")]
+		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: 0x06002A10 RID: 10768 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A10")]
+		[Address(RVA = "0x20B4AF0", Offset = "0x20B38F0", VA = "0x1820B4AF0")]
+		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: 0x1700063C RID: 1596
+		// (get) Token: 0x06002A11 RID: 10769 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x1700063C")]
+		public Task<TResult> Task
+		{
+			[Token(Token = "0x6002A11")]
+			[Address(RVA = "0x2E9A550", Offset = "0x2E99350", VA = "0x182E9A550")]
+			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: 0x06002A12 RID: 10770 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A12")]
+		[Address(RVA = "0x2E98820", Offset = "0x2E97620", VA = "0x182E98820")]
+		public void SetResult(TResult result)
+		{
+		}
+
+		// Token: 0x06002A13 RID: 10771 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A13")]
+		[Address(RVA = "0x2E98A10", Offset = "0x2E97810", VA = "0x182E98A10")]
+		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: 0x06002A14 RID: 10772 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A14")]
+		[Address(RVA = "0x2E97BC0", Offset = "0x2E969C0", VA = "0x182E97BC0")]
+		public void SetException(Exception exception)
+		{
+		}
+
+		// Token: 0x06002A15 RID: 10773 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002A15")]
+		[Address(RVA = "0x2E90920", Offset = "0x2E8F720", VA = "0x182E90920")]
+		private Task<TResult> GetTaskForResult(TResult result)
+		{
+			return null;
+		}
+
+		// Token: 0x0400186D RID: 6253
+		[Token(Token = "0x400186D")]
+		internal static readonly Task<TResult> s_defaultResultTask;
+
+		// Token: 0x0400186E RID: 6254
+		[FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x400186E")]
+		private AsyncMethodBuilderCore m_coreState;
+
+		// Token: 0x0400186F RID: 6255
+		[FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x400186F")]
+		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: 0x02000534 RID: 1332
+	[Token(Token = "0x2000534")]
+	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: 0x06002A03 RID: 10755 RVA: 0x000167E8 File Offset: 0x000149E8
+		[Token(Token = "0x6002A03")]
+		[Address(RVA = "0x147A860", Offset = "0x1479660", VA = "0x18147A860")]
+		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: 0x06002A04 RID: 10756 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A04")]
+		[Address(RVA = "0x19ED110", Offset = "0x19EBF10", VA = "0x1819ED110")]
+		[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: 0x06002A05 RID: 10757 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A05")]
+		[Address(RVA = "0x294B9E0", Offset = "0x294A7E0", VA = "0x18294B9E0")]
+		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: 0x06002A06 RID: 10758 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A06")]
+		[Address(RVA = "0x19EC900", Offset = "0x19EB700", VA = "0x1819EC900")]
+		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: 0x06002A07 RID: 10759 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A07")]
+		[Address(RVA = "0x19ECA20", Offset = "0x19EB820", VA = "0x1819ECA20")]
+		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: 0x1700063B RID: 1595
+		// (get) Token: 0x06002A08 RID: 10760 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x1700063B")]
+		public Task Task
+		{
+			[Token(Token = "0x6002A08")]
+			[Address(RVA = "0x294BAA0", Offset = "0x294A8A0", VA = "0x18294BAA0")]
+			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: 0x06002A09 RID: 10761 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A09")]
+		[Address(RVA = "0x294B970", Offset = "0x294A770", VA = "0x18294B970")]
+		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: 0x06002A0A RID: 10762 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A0A")]
+		[Address(RVA = "0x294B920", Offset = "0x294A720", VA = "0x18294B920")]
+		public void SetException(Exception exception)
+		{
+		}
+
+		// Token: 0x0400186B RID: 6251
+		[Token(Token = "0x400186B")]
+		private static readonly Task<VoidTaskResult> s_cachedCompleted;
+
+		// Token: 0x0400186C RID: 6252
+		[FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x400186C")]
+		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: 0x02000533 RID: 1331
+	[Token(Token = "0x2000533")]
+	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: 0x060029FB RID: 10747 RVA: 0x000167D0 File Offset: 0x000149D0
+		[Token(Token = "0x60029FB")]
+		[Address(RVA = "0x294BAE0", Offset = "0x294A8E0", VA = "0x18294BAE0")]
+		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: 0x060029FC RID: 10748 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60029FC")]
+		[Address(RVA = "0x16D1600", Offset = "0x16D0400", VA = "0x1816D1600")]
+		[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: 0x060029FD RID: 10749 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60029FD")]
+		[Address(RVA = "0x294BDD0", Offset = "0x294ABD0", VA = "0x18294BDD0")]
+		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: 0x060029FE RID: 10750 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60029FE")]
+		[Address(RVA = "0x16CB490", Offset = "0x16CA290", VA = "0x1816CB490")]
+		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: 0x060029FF RID: 10751 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60029FF")]
+		[Address(RVA = "0x294BD30", Offset = "0x294AB30", VA = "0x18294BD30")]
+		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: 0x06002A00 RID: 10752 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A00")]
+		[Address(RVA = "0x294BBD0", Offset = "0x294A9D0", VA = "0x18294BBD0")]
+		public void SetException(Exception exception)
+		{
+		}
+
+		// Token: 0x06002A01 RID: 10753 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A01")]
+		[Address(RVA = "0x294BB50", Offset = "0x294A950", VA = "0x18294BB50")]
+		private void NotifySynchronizationContextOfCompletion()
+		{
+		}
+
+		// Token: 0x1700063A RID: 1594
+		// (get) Token: 0x06002A02 RID: 10754 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x1700063A")]
+		private Task Task
+		{
+			[Token(Token = "0x6002A02")]
+			[Address(RVA = "0x294BDE0", Offset = "0x294ABE0", VA = "0x18294BDE0")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x04001868 RID: 6248
+		[FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x4001868")]
+		private SynchronizationContext m_synchronizationContext;
+
+		// Token: 0x04001869 RID: 6249
+		[FieldOffset(Offset = "0x8")]
+		[Token(Token = "0x4001869")]
+		private AsyncMethodBuilderCore m_coreState;
+
+		// Token: 0x0400186A RID: 6250
+		[FieldOffset(Offset = "0x18")]
+		[Token(Token = "0x400186A")]
+		private Task m_task;
+	}
+}

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: 0x0200053D RID: 1341
+	[Token(Token = "0x200053D")]
+	[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: 0x06002A2D RID: 10797 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A2D")]
+		[Address(RVA = "0x4093D0", Offset = "0x4081D0", VA = "0x1804093D0")]
+		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: 0x02000551 RID: 1361
+	[Token(Token = "0x2000551")]
+	[Flags]
+	[ComVisible(true)]
+	[Serializable]
+	public enum CompilationRelaxations
+	{
+		/// <summary>Marks an assembly as not requiring string-literal interning.</summary>
+		// Token: 0x04001896 RID: 6294
+		[Token(Token = "0x4001896")]
+		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: 0x02000552 RID: 1362
+	[Token(Token = "0x2000552")]
+	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Method)]
+	[ComVisible(true)]
+	[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: 0x06002A64 RID: 10852 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A64")]
+		[Address(RVA = "0x4D83A0", Offset = "0x4D71A0", VA = "0x1804D83A0")]
+		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: 0x06002A65 RID: 10853 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A65")]
+		[Address(RVA = "0x4D83A0", Offset = "0x4D71A0", VA = "0x1804D83A0")]
+		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: 0x17000646 RID: 1606
+		// (get) Token: 0x06002A66 RID: 10854 RVA: 0x000168D8 File Offset: 0x00014AD8
+		[Token(Token = "0x17000646")]
+		public int CompilationRelaxations
+		{
+			[Token(Token = "0x6002A66")]
+			[Address(RVA = "0x3FA560", Offset = "0x3F9360", VA = "0x1803FA560")]
+			get
+			{
+				return 0;
+			}
+		}
+
+		// Token: 0x04001897 RID: 6295
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x4001897")]
+		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: 0x02000553 RID: 1363
+	[Token(Token = "0x2000553")]
+	[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: 0x06002A67 RID: 10855 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A67")]
+		[Address(RVA = "0x4093D0", Offset = "0x4081D0", VA = "0x1804093D0")]
+		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: 0x02000562 RID: 1378
+	[Token(Token = "0x2000562")]
+	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: 0x06002A7D RID: 10877 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A7D")]
+		[Address(RVA = "0x28E6DC0", Offset = "0x28E5BC0", VA = "0x1828E6DC0")]
+		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: 0x06002A7E RID: 10878 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A7E")]
+		[Address(RVA = "0x28E6000", Offset = "0x28E4E00", VA = "0x1828E6000", Slot = "1")]
+		protected override void Finalize()
+		{
+		}
+
+		// Token: 0x06002A7F RID: 10879 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A7F")]
+		[Address(RVA = "0x28E62B0", Offset = "0x28E50B0", VA = "0x1828E62B0")]
+		private void RehashWithoutResize()
+		{
+		}
+
+		// Token: 0x06002A80 RID: 10880 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A80")]
+		[Address(RVA = "0x28E6240", Offset = "0x28E5040", VA = "0x1828E6240")]
+		private void RecomputeSize()
+		{
+		}
+
+		// Token: 0x06002A81 RID: 10881 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A81")]
+		[Address(RVA = "0x28E6530", Offset = "0x28E5330", VA = "0x1828E6530")]
+		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: 0x06002A82 RID: 10882 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A82")]
+		[Address(RVA = "0x28E5D20", Offset = "0x28E4B20", VA = "0x1828E5D20")]
+		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: 0x06002A83 RID: 10883 RVA: 0x00016968 File Offset: 0x00014B68
+		[Token(Token = "0x6002A83")]
+		[Address(RVA = "0x28E6860", Offset = "0x28E5660", VA = "0x1828E6860")]
+		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: 0x06002A84 RID: 10884 RVA: 0x00016980 File Offset: 0x00014B80
+		[Token(Token = "0x6002A84")]
+		[Address(RVA = "0x28E6B00", Offset = "0x28E5900", VA = "0x1828E6B00")]
+		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: 0x06002A85 RID: 10885 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002A85")]
+		[Address(RVA = "0x28E6070", Offset = "0x28E4E70", VA = "0x1828E6070")]
+		public TValue GetValue(TKey key, ConditionalWeakTable<TKey, TValue>.CreateValueCallback createValueCallback)
+		{
+			return null;
+		}
+
+		// Token: 0x040018A1 RID: 6305
+		[Token(Token = "0x40018A1")]
+		private const int INITIAL_SIZE = 13;
+
+		// Token: 0x040018A2 RID: 6306
+		[Token(Token = "0x40018A2")]
+		private const float LOAD_FACTOR = 0.7f;
+
+		// Token: 0x040018A3 RID: 6307
+		[Token(Token = "0x40018A3")]
+		private const float COMPACT_FACTOR = 0.5f;
+
+		// Token: 0x040018A4 RID: 6308
+		[Token(Token = "0x40018A4")]
+		private const float EXPAND_FACTOR = 1.1f;
+
+		// Token: 0x040018A5 RID: 6309
+		[FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x40018A5")]
+		private Ephemeron[] data;
+
+		// Token: 0x040018A6 RID: 6310
+		[FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x40018A6")]
+		private object _lock;
+
+		// Token: 0x040018A7 RID: 6311
+		[FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x40018A7")]
+		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: 0x02000563 RID: 1379
+		// (Invoke) Token: 0x06002A87 RID: 10887
+		[Token(Token = "0x2000563")]
+		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: 0x02000549 RID: 1353
+	[Token(Token = "0x2000549")]
+	public struct ConfiguredTaskAwaitable<TResult>
+	{
+		// Token: 0x06002A51 RID: 10833 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A51")]
+		[Address(RVA = "0x28E6E60", Offset = "0x28E5C60", VA = "0x1828E6E60")]
+		internal ConfiguredTaskAwaitable(Task<TResult> task, bool continueOnCapturedContext)
+		{
+		}
+
+		/// <summary>Returns an awaiter for this awaitable object.</summary>
+		/// <returns>The awaiter.</returns>
+		// Token: 0x06002A52 RID: 10834 RVA: 0x00016878 File Offset: 0x00014A78
+		[Token(Token = "0x6002A52")]
+		[Address(RVA = "0x723D40", Offset = "0x722B40", VA = "0x180723D40")]
+		public ConfiguredTaskAwaitable<TResult>.ConfiguredTaskAwaiter GetAwaiter()
+		{
+			return default(ConfiguredTaskAwaitable<TResult>.ConfiguredTaskAwaiter);
+		}
+
+		// Token: 0x04001888 RID: 6280
+		[FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x4001888")]
+		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: 0x0200054A RID: 1354
+		[Token(Token = "0x200054A")]
+		public struct ConfiguredTaskAwaiter : ICriticalNotifyCompletion, INotifyCompletion
+		{
+			// Token: 0x06002A53 RID: 10835 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6002A53")]
+			[Address(RVA = "0x139F300", Offset = "0x139E100", VA = "0x18139F300")]
+			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: 0x17000643 RID: 1603
+			// (get) Token: 0x06002A54 RID: 10836 RVA: 0x00016890 File Offset: 0x00014A90
+			[Token(Token = "0x17000643")]
+			public bool IsCompleted
+			{
+				[Token(Token = "0x6002A54")]
+				[Address(RVA = "0x28E73F0", Offset = "0x28E61F0", VA = "0x1828E73F0")]
+				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: 0x06002A55 RID: 10837 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6002A55")]
+			[Address(RVA = "0x28E7390", Offset = "0x28E6190", VA = "0x1828E7390", 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: 0x06002A56 RID: 10838 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6002A56")]
+			[Address(RVA = "0x28E73C0", Offset = "0x28E61C0", VA = "0x1828E73C0", 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: 0x06002A57 RID: 10839 RVA: 0x00002082 File Offset: 0x00000282
+			[Token(Token = "0x6002A57")]
+			[Address(RVA = "0x28E6EC0", Offset = "0x28E5CC0", VA = "0x1828E6EC0")]
+			public TResult GetResult()
+			{
+				return null;
+			}
+
+			// Token: 0x04001889 RID: 6281
+			[FieldOffset(Offset = "0x0")]
+			[Token(Token = "0x4001889")]
+			private readonly Task<TResult> m_task;
+
+			// Token: 0x0400188A RID: 6282
+			[FieldOffset(Offset = "0x0")]
+			[Token(Token = "0x400188A")]
+			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: 0x02000547 RID: 1351
+	[Token(Token = "0x2000547")]
+	public struct ConfiguredTaskAwaitable
+	{
+		// Token: 0x06002A4A RID: 10826 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A4A")]
+		[Address(RVA = "0x294C070", Offset = "0x294AE70", VA = "0x18294C070")]
+		internal ConfiguredTaskAwaitable(Task task, bool continueOnCapturedContext)
+		{
+		}
+
+		/// <summary>Returns an awaiter for this awaitable object.</summary>
+		/// <returns>The awaiter.</returns>
+		// Token: 0x06002A4B RID: 10827 RVA: 0x00016848 File Offset: 0x00014A48
+		[Token(Token = "0x6002A4B")]
+		[Address(RVA = "0x723D40", Offset = "0x722B40", VA = "0x180723D40")]
+		public ConfiguredTaskAwaitable.ConfiguredTaskAwaiter GetAwaiter()
+		{
+			return default(ConfiguredTaskAwaitable.ConfiguredTaskAwaiter);
+		}
+
+		// Token: 0x04001885 RID: 6277
+		[FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x4001885")]
+		private readonly ConfiguredTaskAwaitable.ConfiguredTaskAwaiter m_configuredTaskAwaiter;
+
+		/// <summary>Provides an awaiter for an awaitable (<see cref="T:System.Runtime.CompilerServices.ConfiguredTaskAwaitable" />) object.</summary>
+		// Token: 0x02000548 RID: 1352
+		[Token(Token = "0x2000548")]
+		public struct ConfiguredTaskAwaiter : ICriticalNotifyCompletion, INotifyCompletion
+		{
+			// Token: 0x06002A4C RID: 10828 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6002A4C")]
+			[Address(RVA = "0x139F300", Offset = "0x139E100", VA = "0x18139F300")]
+			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: 0x17000642 RID: 1602
+			// (get) Token: 0x06002A4D RID: 10829 RVA: 0x00016860 File Offset: 0x00014A60
+			[Token(Token = "0x17000642")]
+			public bool IsCompleted
+			{
+				[Token(Token = "0x6002A4D")]
+				[Address(RVA = "0x28E73F0", Offset = "0x28E61F0", VA = "0x1828E73F0")]
+				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: 0x06002A4E RID: 10830 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6002A4E")]
+			[Address(RVA = "0x28E7390", Offset = "0x28E6190", VA = "0x1828E7390", 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: 0x06002A4F RID: 10831 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6002A4F")]
+			[Address(RVA = "0x28E73C0", Offset = "0x28E61C0", VA = "0x1828E73C0", 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: 0x06002A50 RID: 10832 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6002A50")]
+			[Address(RVA = "0x294C090", Offset = "0x294AE90", VA = "0x18294C090")]
+			public void GetResult()
+			{
+			}
+
+			// Token: 0x04001886 RID: 6278
+			[FieldOffset(Offset = "0x0")]
+			[Token(Token = "0x4001886")]
+			private readonly Task m_task;
+
+			// Token: 0x04001887 RID: 6279
+			[FieldOffset(Offset = "0x8")]
+			[Token(Token = "0x4001887")]
+			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: 0x02000554 RID: 1364
+	[Token(Token = "0x2000554")]
+	[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: 0x17000647 RID: 1607
+		// (get) Token: 0x06002A68 RID: 10856
+		[Token(Token = "0x17000647")]
+		public abstract object Value
+		{
+			[Token(Token = "0x6002A68")]
+			[Address(Slot = "7")]
+			get;
+		}
+
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.CompilerServices.CustomConstantAttribute" /> class.</summary>
+		// Token: 0x06002A69 RID: 10857 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A69")]
+		[Address(RVA = "0x4093D0", Offset = "0x4081D0", VA = "0x1804093D0")]
+		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: 0x02000555 RID: 1365
+	[Token(Token = "0x2000555")]
+	[ComVisible(true)]
+	[AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter)]
+	[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: 0x17000648 RID: 1608
+		// (get) Token: 0x06002A6A RID: 10858 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x17000648")]
+		public override object Value
+		{
+			[Token(Token = "0x6002A6A")]
+			[Address(RVA = "0x294C1C0", Offset = "0x294AFC0", VA = "0x18294C1C0", Slot = "7")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x04001898 RID: 6296
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x4001898")]
+		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: 0x02000556 RID: 1366
+	[Token(Token = "0x2000556")]
+	[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: 0x06002A6B RID: 10859 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A6B")]
+		[Address(RVA = "0x294C210", Offset = "0x294B010", VA = "0x18294C210")]
+		[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: 0x17000649 RID: 1609
+		// (get) Token: 0x06002A6C RID: 10860 RVA: 0x000168F0 File Offset: 0x00014AF0
+		[Token(Token = "0x17000649")]
+		public decimal Value
+		{
+			[Token(Token = "0x6002A6C")]
+			[Address(RVA = "0x6808B0", Offset = "0x67F6B0", VA = "0x1806808B0")]
+			get
+			{
+				return 0m;
+			}
+		}
+
+		// Token: 0x04001899 RID: 6297
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x4001899")]
+		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: 0x0200054F RID: 1359
+	[Token(Token = "0x200054F")]
+	[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: 0x06002A62 RID: 10850 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A62")]
+		[Address(RVA = "0x4D83A0", Offset = "0x4D71A0", VA = "0x1804D83A0")]
+		public DefaultDependencyAttribute(LoadHint loadHintArgument)
+		{
+		}
+
+		// Token: 0x04001892 RID: 6290
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x4001892")]
+		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: 0x02000550 RID: 1360
+	[Token(Token = "0x2000550")]
+	[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: 0x06002A63 RID: 10851 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A63")]
+		[Address(RVA = "0x582150", Offset = "0x580F50", VA = "0x180582150")]
+		public DependencyAttribute(string dependentAssemblyArgument, LoadHint loadHintArgument)
+		{
+		}
+
+		// Token: 0x04001893 RID: 6291
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x4001893")]
+		private string dependentAssembly;
+
+		// Token: 0x04001894 RID: 6292
+		[FieldOffset(Offset = "0x18")]
+		[Token(Token = "0x4001894")]
+		private LoadHint loadHint;
+	}
+}

mscorlib/System/Runtime/CompilerServices/Ephemeron.cs

@@ -0,0 +1,20 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	// Token: 0x02000561 RID: 1377
+	[Token(Token = "0x2000561")]
+	internal struct Ephemeron
+	{
+		// Token: 0x0400189F RID: 6303
+		[FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x400189F")]
+		internal object key;
+
+		// Token: 0x040018A0 RID: 6304
+		[FieldOffset(Offset = "0x8")]
+		[Token(Token = "0x40018A0")]
+		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: 0x02000557 RID: 1367
+	[Token(Token = "0x2000557")]
+	[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: 0x06002A6D RID: 10861 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A6D")]
+		[Address(RVA = "0x4093D0", Offset = "0x4081D0", VA = "0x1804093D0")]
+		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: 0x02000558 RID: 1368
+	[Token(Token = "0x2000558")]
+	[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: 0x06002A6E RID: 10862 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A6E")]
+		[Address(RVA = "0x582150", Offset = "0x580F50", VA = "0x180582150")]
+		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: 0x1700064A RID: 1610
+		// (get) Token: 0x06002A6F RID: 10863 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x1700064A")]
+		public Type ElementType
+		{
+			[Token(Token = "0x6002A6F")]
+			[Address(RVA = "0x3F6E20", Offset = "0x3F5C20", VA = "0x1803F6E20")]
+			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: 0x1700064B RID: 1611
+		// (get) Token: 0x06002A70 RID: 10864 RVA: 0x00016908 File Offset: 0x00014B08
+		[Token(Token = "0x1700064B")]
+		public int Length
+		{
+			[Token(Token = "0x6002A70")]
+			[Address(RVA = "0x40B720", Offset = "0x40A520", VA = "0x18040B720")]
+			get
+			{
+				return 0;
+			}
+		}
+
+		// Token: 0x0400189A RID: 6298
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x400189A")]
+		private Type elementType;
+
+		// Token: 0x0400189B RID: 6299
+		[FieldOffset(Offset = "0x18")]
+		[Token(Token = "0x400189B")]
+		private int length;
+	}
+}

mscorlib/System/Runtime/CompilerServices/FriendAccessAllowedAttribute.cs

@@ -0,0 +1,19 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	// Token: 0x0200055A RID: 1370
+	[Token(Token = "0x200055A")]
+	[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: 0x06002A75 RID: 10869 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A75")]
+		[Address(RVA = "0x4093D0", Offset = "0x4081D0", VA = "0x1804093D0")]
+		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: 0x0200053E RID: 1342
+	[Token(Token = "0x200053E")]
+	public interface IAsyncStateMachine
+	{
+		/// <summary>Moves the state machine to its next state.</summary>
+		// Token: 0x06002A2E RID: 10798
+		[Token(Token = "0x6002A2E")]
+		[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: 0x06002A2F RID: 10799
+		[Token(Token = "0x6002A2F")]
+		[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: 0x02000540 RID: 1344
+	[Token(Token = "0x2000540")]
+	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: 0x06002A31 RID: 10801
+		[Token(Token = "0x6002A31")]
+		[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: 0x0200053F RID: 1343
+	[Token(Token = "0x200053F")]
+	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: 0x06002A30 RID: 10800
+		[Token(Token = "0x6002A30")]
+		[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: 0x02000559 RID: 1369
+	[Token(Token = "0x2000559")]
+	[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: 0x06002A71 RID: 10865 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A71")]
+		[Address(RVA = "0x294D510", Offset = "0x294C310", VA = "0x18294D510")]
+		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: 0x1700064C RID: 1612
+		// (get) Token: 0x06002A72 RID: 10866 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x1700064C")]
+		public string AssemblyName
+		{
+			[Token(Token = "0x6002A72")]
+			[Address(RVA = "0x3F6E20", Offset = "0x3F5C20", VA = "0x1803F6E20")]
+			get
+			{
+				return null;
+			}
+		}
+
+		/// <summary>This property is not implemented.</summary>
+		/// <returns>This property does not return a value.</returns>
+		// Token: 0x1700064D RID: 1613
+		// (get) Token: 0x06002A73 RID: 10867 RVA: 0x00016920 File Offset: 0x00014B20
+		// (set) Token: 0x06002A74 RID: 10868 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x1700064D")]
+		public bool AllInternalsVisible
+		{
+			[Token(Token = "0x6002A73")]
+			[Address(RVA = "0x42C2C0", Offset = "0x42B0C0", VA = "0x18042C2C0")]
+			get
+			{
+				return default(bool);
+			}
+			[Token(Token = "0x6002A74")]
+			[Address(RVA = "0x43DE90", Offset = "0x43CC90", VA = "0x18043DE90")]
+			set
+			{
+			}
+		}
+
+		// Token: 0x0400189C RID: 6300
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x400189C")]
+		private string _assemblyName;
+
+		// Token: 0x0400189D RID: 6301
+		[FieldOffset(Offset = "0x18")]
+		[Token(Token = "0x400189D")]
+		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: 0x02000530 RID: 1328
+	[Token(Token = "0x2000530")]
+	[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: 0x060029F8 RID: 10744 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60029F8")]
+		[Address(RVA = "0x4093D0", Offset = "0x4081D0", VA = "0x1804093D0")]
+		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: 0x02000531 RID: 1329
+	[Token(Token = "0x2000531")]
+	[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: 0x060029F9 RID: 10745 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60029F9")]
+		[Address(RVA = "0x4093D0", Offset = "0x4081D0", VA = "0x1804093D0")]
+		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: 0x0200055B RID: 1371
+	[Token(Token = "0x200055B")]
+	[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: 0x02000541 RID: 1345
+	[Token(Token = "0x2000541")]
+	[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: 0x06002A32 RID: 10802 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A32")]
+		[Address(RVA = "0x462000", Offset = "0x460E00", VA = "0x180462000")]
+		public IteratorStateMachineAttribute(Type stateMachineType)
+		{
+		}
+	}
+}

mscorlib/System/Runtime/CompilerServices/JitHelpers.cs

@@ -0,0 +1,34 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	// Token: 0x02000560 RID: 1376
+	[Token(Token = "0x2000560")]
+	[FriendAccessAllowed]
+	internal static class JitHelpers
+	{
+		// Token: 0x06002A7A RID: 10874 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002A7A")]
+		[Address(RVA = "0x1297C50", Offset = "0x1296A50", VA = "0x181297C50")]
+		internal static T UnsafeCast<T>(object o) where T : class
+		{
+			return null;
+		}
+
+		// Token: 0x06002A7B RID: 10875 RVA: 0x00016938 File Offset: 0x00014B38
+		[Token(Token = "0x6002A7B")]
+		[Address(RVA = "0x1297C50", Offset = "0x1296A50", VA = "0x181297C50")]
+		internal static int UnsafeEnumCast<T>(T val) where T : struct
+		{
+			return 0;
+		}
+
+		// Token: 0x06002A7C RID: 10876 RVA: 0x00016950 File Offset: 0x00014B50
+		[Token(Token = "0x6002A7C")]
+		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: 0x0200054E RID: 1358
+	[Token(Token = "0x200054E")]
+	[Serializable]
+	public enum LoadHint
+	{
+		/// <summary>No preference specified.</summary>
+		// Token: 0x0400188F RID: 6287
+		[Token(Token = "0x400188F")]
+		Default,
+		/// <summary>The dependency is always loaded.</summary>
+		// Token: 0x04001890 RID: 6288
+		[Token(Token = "0x4001890")]
+		Always,
+		/// <summary>The dependency is sometimes loaded.</summary>
+		// Token: 0x04001891 RID: 6289
+		[Token(Token = "0x4001891")]
+		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: 0x02000542 RID: 1346
+	[Token(Token = "0x2000542")]
+	[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: 0x06002A33 RID: 10803 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A33")]
+		[Address(RVA = "0x4093D0", Offset = "0x4081D0", VA = "0x1804093D0")]
+		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: 0x1700063D RID: 1597
+		// (set) Token: 0x06002A34 RID: 10804 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x1700063D")]
+		public bool WrapNonExceptionThrows
+		{
+			[Token(Token = "0x6002A34")]
+			[Address(RVA = "0x495D50", Offset = "0x494B50", VA = "0x180495D50")]
+			set
+			{
+			}
+		}
+
+		// Token: 0x04001880 RID: 6272
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x4001880")]
+		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: 0x02000564 RID: 1380
+	[Token(Token = "0x2000564")]
+	public static class RuntimeHelpers
+	{
+		// Token: 0x06002A8A RID: 10890 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A8A")]
+		[Address(RVA = "0x295DBE0", Offset = "0x295C9E0", VA = "0x18295DBE0")]
+		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: 0x06002A8B RID: 10891 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A8B")]
+		[Address(RVA = "0x295DB60", Offset = "0x295C960", VA = "0x18295DB60")]
+		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: 0x1700064E RID: 1614
+		// (get) Token: 0x06002A8C RID: 10892 RVA: 0x00016998 File Offset: 0x00014B98
+		[Token(Token = "0x1700064E")]
+		public static int OffsetToStringData
+		{
+			[Token(Token = "0x6002A8C")]
+			[Address(RVA = "0x295DC80", Offset = "0x295CA80", VA = "0x18295DC80")]
+			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: 0x06002A8D RID: 10893 RVA: 0x000169B0 File Offset: 0x00014BB0
+		[Token(Token = "0x6002A8D")]
+		[Address(RVA = "0x19424F0", Offset = "0x19412F0", VA = "0x1819424F0")]
+		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: 0x06002A8E RID: 10894 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002A8E")]
+		[Address(RVA = "0x295DB50", Offset = "0x295C950", VA = "0x18295DB50")]
+		public static object GetObjectValue(object obj)
+		{
+			return null;
+		}
+
+		// Token: 0x06002A8F RID: 10895 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A8F")]
+		[Address(RVA = "0x295DC70", Offset = "0x295CA70", VA = "0x18295DC70")]
+		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: 0x06002A90 RID: 10896 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A90")]
+		[Address(RVA = "0x295DBF0", Offset = "0x295C9F0", VA = "0x18295DBF0")]
+		public static void RunClassConstructor(RuntimeTypeHandle type)
+		{
+		}
+
+		// Token: 0x06002A91 RID: 10897 RVA: 0x000169C8 File Offset: 0x00014BC8
+		[Token(Token = "0x6002A91")]
+		[Address(RVA = "0x2379AE0", Offset = "0x23788E0", VA = "0x182379AE0")]
+		private static bool SufficientExecutionStack()
+		{
+			return default(bool);
+		}
+
+		// Token: 0x06002A92 RID: 10898 RVA: 0x000169E0 File Offset: 0x00014BE0
+		[Token(Token = "0x6002A92")]
+		[Address(RVA = "0x2379AE0", Offset = "0x23788E0", VA = "0x182379AE0")]
+		public static bool TryEnsureSufficientExecutionStack()
+		{
+			return default(bool);
+		}
+
+		/// <summary>Designates a body of code as a constrained execution region (CER).</summary>
+		// Token: 0x06002A93 RID: 10899 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A93")]
+		[Address(RVA = "0x402080", Offset = "0x400E80", VA = "0x180402080")]
+		[MonoTODO]
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
+		[MonoTODO("Currently a no-op")]
+		public static void PrepareConstrainedRegions()
+		{
+		}
+
+		// Token: 0x06002A94 RID: 10900 RVA: 0x000169F8 File Offset: 0x00014BF8
+		[Token(Token = "0x6002A94")]
+		[Address(RVA = "0x190E080", Offset = "0x190CE80", VA = "0x18190E080")]
+		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: 0x02000543 RID: 1347
+	[Token(Token = "0x2000543")]
+	[Serializable]
+	public sealed class RuntimeWrappedException : Exception
+	{
+		// Token: 0x06002A35 RID: 10805 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A35")]
+		[Address(RVA = "0x295FB20", Offset = "0x295E920", VA = "0x18295FB20")]
+		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: 0x1700063E RID: 1598
+		// (get) Token: 0x06002A36 RID: 10806 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x1700063E")]
+		public object WrappedException
+		{
+			[Token(Token = "0x6002A36")]
+			[Address(RVA = "0x44EC80", Offset = "0x44DA80", VA = "0x18044EC80")]
+			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: 0x06002A37 RID: 10807 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A37")]
+		[Address(RVA = "0x295FA30", Offset = "0x295E830", VA = "0x18295FA30", Slot = "10")]
+		public override void GetObjectData(SerializationInfo info, StreamingContext context)
+		{
+		}
+
+		// Token: 0x06002A38 RID: 10808 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A38")]
+		[Address(RVA = "0x295FBF0", Offset = "0x295E9F0", VA = "0x18295FBF0")]
+		internal RuntimeWrappedException(SerializationInfo info, StreamingContext context)
+		{
+		}
+
+		// Token: 0x06002A39 RID: 10809 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A39")]
+		[Address(RVA = "0x295FBC0", Offset = "0x295E9C0", VA = "0x18295FBC0")]
+		internal RuntimeWrappedException()
+		{
+		}
+
+		// Token: 0x04001881 RID: 6273
+		[FieldOffset(Offset = "0x88")]
+		[Token(Token = "0x4001881")]
+		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: 0x02000544 RID: 1348
+	[Token(Token = "0x2000544")]
+	[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: 0x1700063F RID: 1599
+		// (set) Token: 0x06002A3A RID: 10810 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x1700063F")]
+		private Type StateMachineType
+		{
+			[Token(Token = "0x6002A3A")]
+			[Address(RVA = "0x3F7200", Offset = "0x3F6000", VA = "0x1803F7200")]
+			[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: 0x06002A3B RID: 10811 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A3B")]
+		[Address(RVA = "0x462000", Offset = "0x460E00", VA = "0x180462000")]
+		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: 0x0200055F RID: 1375
+	[Token(Token = "0x200055F")]
+	[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: 0x06002A79 RID: 10873 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A79")]
+		[Address(RVA = "0x4093D0", Offset = "0x4081D0", VA = "0x1804093D0")]
+		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: 0x0200055C RID: 1372
+	[Token(Token = "0x200055C")]
+	[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: 0x06002A76 RID: 10870 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A76")]
+		[Address(RVA = "0x4093D0", Offset = "0x4081D0", VA = "0x1804093D0")]
+		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: 0x02000546 RID: 1350
+	[Token(Token = "0x2000546")]
+	public struct TaskAwaiter<TResult> : ICriticalNotifyCompletion, INotifyCompletion
+	{
+		// Token: 0x06002A45 RID: 10821 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A45")]
+		[Address(RVA = "0x461A30", Offset = "0x460830", VA = "0x180461A30")]
+		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: 0x17000641 RID: 1601
+		// (get) Token: 0x06002A46 RID: 10822 RVA: 0x00016830 File Offset: 0x00014A30
+		[Token(Token = "0x17000641")]
+		public bool IsCompleted
+		{
+			[Token(Token = "0x6002A46")]
+			[Address(RVA = "0x28E73F0", Offset = "0x28E61F0", VA = "0x1828E73F0")]
+			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: 0x06002A47 RID: 10823 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A47")]
+		[Address(RVA = "0x28EBB20", Offset = "0x28EA920", VA = "0x1828EBB20", 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: 0x06002A48 RID: 10824 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A48")]
+		[Address(RVA = "0x28EBB50", Offset = "0x28EA950", VA = "0x1828EBB50", 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: 0x06002A49 RID: 10825 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002A49")]
+		[Address(RVA = "0x28E6EC0", Offset = "0x28E5CC0", VA = "0x1828E6EC0")]
+		public TResult GetResult()
+		{
+			return null;
+		}
+
+		// Token: 0x04001884 RID: 6276
+		[FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x4001884")]
+		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: 0x02000545 RID: 1349
+	[Token(Token = "0x2000545")]
+	public struct TaskAwaiter : ICriticalNotifyCompletion, INotifyCompletion
+	{
+		// Token: 0x06002A3C RID: 10812 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A3C")]
+		[Address(RVA = "0x461A30", Offset = "0x460830", VA = "0x180461A30")]
+		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: 0x17000640 RID: 1600
+		// (get) Token: 0x06002A3D RID: 10813 RVA: 0x00016818 File Offset: 0x00014A18
+		[Token(Token = "0x17000640")]
+		public bool IsCompleted
+		{
+			[Token(Token = "0x6002A3D")]
+			[Address(RVA = "0x28E73F0", Offset = "0x28E61F0", VA = "0x1828E73F0")]
+			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: 0x06002A3E RID: 10814 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A3E")]
+		[Address(RVA = "0x28EBB20", Offset = "0x28EA920", VA = "0x1828EBB20", 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: 0x06002A3F RID: 10815 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A3F")]
+		[Address(RVA = "0x28EBB50", Offset = "0x28EA950", VA = "0x1828EBB50", 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: 0x06002A40 RID: 10816 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A40")]
+		[Address(RVA = "0x294C090", Offset = "0x294AE90", VA = "0x18294C090")]
+		public void GetResult()
+		{
+		}
+
+		// Token: 0x06002A41 RID: 10817 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A41")]
+		[Address(RVA = "0x2960770", Offset = "0x295F570", VA = "0x182960770")]
+		internal static void ValidateEnd(Task task)
+		{
+		}
+
+		// Token: 0x06002A42 RID: 10818 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A42")]
+		[Address(RVA = "0x2960410", Offset = "0x295F210", VA = "0x182960410")]
+		private static void HandleNonSuccessAndDebuggerNotification(Task task)
+		{
+		}
+
+		// Token: 0x06002A43 RID: 10819 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A43")]
+		[Address(RVA = "0x2960640", Offset = "0x295F440", VA = "0x182960640")]
+		private static void ThrowForNonSuccess(Task task)
+		{
+		}
+
+		// Token: 0x06002A44 RID: 10820 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A44")]
+		[Address(RVA = "0x2960570", Offset = "0x295F370", VA = "0x182960570")]
+		internal static void OnCompletedInternal(Task task, Action continuation, bool continueOnCapturedContext, bool flowExecutionContext)
+		{
+		}
+
+		// Token: 0x04001883 RID: 6275
+		[FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x4001883")]
+		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: 0x02000532 RID: 1330
+	[Token(Token = "0x2000532")]
+	[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: 0x060029FA RID: 10746 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60029FA")]
+		[Address(RVA = "0x29608F0", Offset = "0x295F6F0", VA = "0x1829608F0")]
+		public TupleElementNamesAttribute(string[] transformNames)
+		{
+		}
+
+		// Token: 0x04001867 RID: 6247
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x4001867")]
+		private readonly string[] _transformNames;
+	}
+}

mscorlib/System/Runtime/CompilerServices/TypeDependencyAttribute.cs

@@ -0,0 +1,23 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.CompilerServices
+{
+	// Token: 0x0200055D RID: 1373
+	[Token(Token = "0x200055D")]
+	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface)]
+	internal sealed class TypeDependencyAttribute : Attribute
+	{
+		// Token: 0x06002A77 RID: 10871 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A77")]
+		[Address(RVA = "0x2960970", Offset = "0x295F770", VA = "0x182960970")]
+		public TypeDependencyAttribute(string typeName)
+		{
+		}
+
+		// Token: 0x0400189E RID: 6302
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x400189E")]
+		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: 0x0200054B RID: 1355
+	[Token(Token = "0x200054B")]
+	[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: 0x06002A58 RID: 10840 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A58")]
+		[Address(RVA = "0x29609F0", Offset = "0x295F7F0", VA = "0x1829609F0")]
+		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: 0x17000644 RID: 1604
+		// (get) Token: 0x06002A59 RID: 10841 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x17000644")]
+		public string AssemblyFullName
+		{
+			[Token(Token = "0x6002A59")]
+			[Address(RVA = "0x3F6E20", Offset = "0x3F5C20", VA = "0x1803F6E20")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x0400188B RID: 6283
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x400188B")]
+		private string assemblyFullName;
+	}
+}

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: 0x0200055E RID: 1374
+	[Token(Token = "0x200055E")]
+	[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: 0x06002A78 RID: 10872 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A78")]
+		[Address(RVA = "0x4093D0", Offset = "0x4081D0", VA = "0x1804093D0")]
+		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: 0x0200054C RID: 1356
+	[Token(Token = "0x200054C")]
+	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: 0x06002A5A RID: 10842 RVA: 0x000168A8 File Offset: 0x00014AA8
+		[Token(Token = "0x6002A5A")]
+		[Address(RVA = "0x403930", Offset = "0x402730", VA = "0x180403930")]
+		public YieldAwaitable.YieldAwaiter GetAwaiter()
+		{
+			return default(YieldAwaitable.YieldAwaiter);
+		}
+
+		/// <summary>Provides an awaiter for switching into a target environment.</summary>
+		// Token: 0x0200054D RID: 1357
+		[Token(Token = "0x200054D")]
+		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: 0x17000645 RID: 1605
+			// (get) Token: 0x06002A5B RID: 10843 RVA: 0x000168C0 File Offset: 0x00014AC0
+			[Token(Token = "0x17000645")]
+			public bool IsCompleted
+			{
+				[Token(Token = "0x6002A5B")]
+				[Address(RVA = "0x403930", Offset = "0x402730", VA = "0x180403930")]
+				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: 0x06002A5C RID: 10844 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6002A5C")]
+			[Address(RVA = "0x2960EF0", Offset = "0x295FCF0", VA = "0x182960EF0", 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: 0x06002A5D RID: 10845 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6002A5D")]
+			[Address(RVA = "0x2961290", Offset = "0x2960090", VA = "0x182961290", Slot = "4")]
+			public void UnsafeOnCompleted(Action continuation)
+			{
+			}
+
+			// Token: 0x06002A5E RID: 10846 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6002A5E")]
+			[Address(RVA = "0x2960F50", Offset = "0x295FD50", VA = "0x182960F50")]
+			private static void QueueContinuation(Action continuation, bool flowContext)
+			{
+			}
+
+			// Token: 0x06002A5F RID: 10847 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6002A5F")]
+			[Address(RVA = "0x2961230", Offset = "0x2960030", VA = "0x182961230")]
+			private static void RunAction(object state)
+			{
+			}
+
+			/// <summary>Ends the await operation.</summary>
+			// Token: 0x06002A60 RID: 10848 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6002A60")]
+			[Address(RVA = "0x402080", Offset = "0x400E80", VA = "0x180402080")]
+			public void GetResult()
+			{
+			}
+
+			// Token: 0x0400188C RID: 6284
+			[Token(Token = "0x400188C")]
+			private static readonly WaitCallback s_waitCallbackRunAction;
+
+			// Token: 0x0400188D RID: 6285
+			[Token(Token = "0x400188D")]
+			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: 0x0200052E RID: 1326
+	[Token(Token = "0x200052E")]
+	[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: 0x04001862 RID: 6242
+		[Token(Token = "0x4001862")]
+		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: 0x04001863 RID: 6243
+		[Token(Token = "0x4001863")]
+		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: 0x04001864 RID: 6244
+		[Token(Token = "0x4001864")]
+		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: 0x0200052D RID: 1325
+	[Token(Token = "0x200052D")]
+	[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: 0x0400185D RID: 6237
+		[Token(Token = "0x400185D")]
+		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: 0x0400185E RID: 6238
+		[Token(Token = "0x400185E")]
+		MayCorruptAppDomain,
+		/// <summary>In the face of exceptional conditions, the method is guaranteed to limit state corruption to the current instance.</summary>
+		// Token: 0x0400185F RID: 6239
+		[Token(Token = "0x400185F")]
+		MayCorruptInstance,
+		/// <summary>In the face of exceptional conditions, the method is guaranteed not to corrupt state.</summary>
+		// Token: 0x04001860 RID: 6240
+		[Token(Token = "0x4001860")]
+		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: 0x0200052B RID: 1323
+	[Token(Token = "0x200052B")]
+	[ComVisible(true)]
+	public abstract class CriticalFinalizerObject
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.ConstrainedExecution.CriticalFinalizerObject" /> class.</summary>
+		// Token: 0x060029F4 RID: 10740 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60029F4")]
+		[Address(RVA = "0x3F5100", Offset = "0x3F3F00", VA = "0x1803F5100")]
+		[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: 0x060029F5 RID: 10741 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60029F5")]
+		[Address(RVA = "0x294C160", Offset = "0x294AF60", VA = "0x18294C160", 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: 0x0200052C RID: 1324
+	[Token(Token = "0x200052C")]
+	[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: 0x060029F6 RID: 10742 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60029F6")]
+		[Address(RVA = "0x4093D0", Offset = "0x4081D0", VA = "0x1804093D0")]
+		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: 0x0200052F RID: 1327
+	[Token(Token = "0x200052F")]
+	[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: 0x060029F7 RID: 10743 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60029F7")]
+		[Address(RVA = "0x29552D0", Offset = "0x29540D0", VA = "0x1829552D0")]
+		public ReliabilityContractAttribute(Consistency consistencyGuarantee, Cer cer)
+		{
+		}
+
+		// Token: 0x04001865 RID: 6245
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x4001865")]
+		private Consistency _consistency;
+
+		// Token: 0x04001866 RID: 6246
+		[FieldOffset(Offset = "0x14")]
+		[Token(Token = "0x4001866")]
+		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: 0x0200052A RID: 1322
+	[Token(Token = "0x200052A")]
+	public sealed class ExceptionDispatchInfo
+	{
+		// Token: 0x060029EE RID: 10734 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60029EE")]
+		[Address(RVA = "0x294C4F0", Offset = "0x294B2F0", VA = "0x18294C4F0")]
+		private ExceptionDispatchInfo(Exception exception)
+		{
+		}
+
+		// Token: 0x17000638 RID: 1592
+		// (get) Token: 0x060029EF RID: 10735 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x17000638")]
+		internal object BinaryStackTraceArray
+		{
+			[Token(Token = "0x60029EF")]
+			[Address(RVA = "0x3F5F40", Offset = "0x3F4D40", VA = "0x1803F5F40")]
+			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: 0x060029F0 RID: 10736 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60029F0")]
+		[Address(RVA = "0x294C2A0", Offset = "0x294B0A0", VA = "0x18294C2A0")]
+		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: 0x17000639 RID: 1593
+		// (get) Token: 0x060029F1 RID: 10737 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x17000639")]
+		public Exception SourceException
+		{
+			[Token(Token = "0x60029F1")]
+			[Address(RVA = "0x3F6E20", Offset = "0x3F5C20", VA = "0x1803F6E20")]
+			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: 0x060029F2 RID: 10738 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60029F2")]
+		[Address(RVA = "0x294C450", Offset = "0x294B250", VA = "0x18294C450")]
+		public void Throw()
+		{
+		}
+
+		// Token: 0x060029F3 RID: 10739 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60029F3")]
+		[Address(RVA = "0x294C4C0", Offset = "0x294B2C0", VA = "0x18294C4C0")]
+		public static void Throw(Exception source)
+		{
+		}
+
+		// Token: 0x0400185A RID: 6234
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x400185A")]
+		private Exception m_Exception;
+
+		// Token: 0x0400185B RID: 6235
+		[FieldOffset(Offset = "0x18")]
+		[Token(Token = "0x400185B")]
+		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: 0x02000529 RID: 1321
+	[Token(Token = "0x2000529")]
+	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: 0x02000528 RID: 1320
+	[Token(Token = "0x2000528")]
+	[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: 0x060029ED RID: 10733 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60029ED")]
+		[Address(RVA = "0x4093D0", Offset = "0x4081D0", VA = "0x1804093D0")]
+		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: 0x0200057C RID: 1404
+	[Token(Token = "0x200057C")]
+	[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: 0x06002AAA RID: 10922 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AAA")]
+		[Address(RVA = "0x294BFE0", Offset = "0x294ADE0", VA = "0x18294BFE0")]
+		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: 0x06002AAB RID: 10923 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AAB")]
+		[Address(RVA = "0x294C040", Offset = "0x294AE40", VA = "0x18294C040")]
+		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: 0x06002AAC RID: 10924 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AAC")]
+		[Address(RVA = "0x4E7140", Offset = "0x4E5F40", VA = "0x1804E7140")]
+		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: 0x06002AAD RID: 10925 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002AAD")]
+		[Address(RVA = "0x294BE40", Offset = "0x294AC40", VA = "0x18294BE40", 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: 0x0200057A RID: 1402
+	[Token(Token = "0x200057A")]
+	[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: 0x04001928 RID: 6440
+		[Token(Token = "0x4001928")]
+		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: 0x04001929 RID: 6441
+		[Token(Token = "0x4001929")]
+		Cdecl,
+		/// <summary>The callee cleans the stack. This is the default convention for calling unmanaged functions with platform invoke.</summary>
+		// Token: 0x0400192A RID: 6442
+		[Token(Token = "0x400192A")]
+		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: 0x0400192B RID: 6443
+		[Token(Token = "0x400192B")]
+		ThisCall,
+		/// <summary>This calling convention is not supported.</summary>
+		// Token: 0x0400192C RID: 6444
+		[Token(Token = "0x400192C")]
+		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: 0x0200057B RID: 1403
+	[Token(Token = "0x200057B")]
+	[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: 0x0400192E RID: 6446
+		[Token(Token = "0x400192E")]
+		None = 1,
+		/// <summary>Marshal strings as multiple-byte character strings.</summary>
+		// Token: 0x0400192F RID: 6447
+		[Token(Token = "0x400192F")]
+		Ansi,
+		/// <summary>Marshal strings as Unicode 2-byte characters.</summary>
+		// Token: 0x04001930 RID: 6448
+		[Token(Token = "0x4001930")]
+		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: 0x04001931 RID: 6449
+		[Token(Token = "0x4001931")]
+		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: 0x0200056B RID: 1387
+	[Token(Token = "0x200056B")]
+	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class)]
+	[ComVisible(true)]
+	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: 0x06002A99 RID: 10905 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A99")]
+		[Address(RVA = "0x4D83A0", Offset = "0x4D71A0", VA = "0x1804D83A0")]
+		public ClassInterfaceAttribute(ClassInterfaceType classInterfaceType)
+		{
+		}
+
+		// Token: 0x040018B9 RID: 6329
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x40018B9")]
+		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: 0x0200056A RID: 1386
+	[Token(Token = "0x200056A")]
+	[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: 0x040018B6 RID: 6326
+		[Token(Token = "0x40018B6")]
+		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: 0x040018B7 RID: 6327
+		[Token(Token = "0x40018B7")]
+		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: 0x040018B8 RID: 6328
+		[Token(Token = "0x40018B8")]
+		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: 0x02000579 RID: 1401
+	[Token(Token = "0x2000579")]
+	[ComVisible(true)]
+	[AttributeUsage(AttributeTargets.Assembly)]
+	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: 0x06002AA9 RID: 10921 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AA9")]
+		[Address(RVA = "0x2370600", Offset = "0x236F400", VA = "0x182370600")]
+		public ComCompatibleVersionAttribute(int major, int minor, int build, int revision)
+		{
+		}
+
+		// Token: 0x04001923 RID: 6435
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x4001923")]
+		internal int _major;
+
+		// Token: 0x04001924 RID: 6436
+		[FieldOffset(Offset = "0x14")]
+		[Token(Token = "0x4001924")]
+		internal int _minor;
+
+		// Token: 0x04001925 RID: 6437
+		[FieldOffset(Offset = "0x18")]
+		[Token(Token = "0x4001925")]
+		internal int _build;
+
+		// Token: 0x04001926 RID: 6438
+		[FieldOffset(Offset = "0x1C")]
+		[Token(Token = "0x4001926")]
+		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: 0x02000569 RID: 1385
+	[Token(Token = "0x2000569")]
+	[AttributeUsage(AttributeTargets.Class)]
+	[ComVisible(true)]
+	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: 0x06002A98 RID: 10904 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A98")]
+		[Address(RVA = "0x462000", Offset = "0x460E00", VA = "0x180462000")]
+		public ComDefaultInterfaceAttribute(Type defaultInterface)
+		{
+		}
+
+		// Token: 0x040018B4 RID: 6324
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x40018B4")]
+		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: 0x0200056F RID: 1391
+	[Token(Token = "0x200056F")]
+	[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: 0x06002A9B RID: 10907 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A9B")]
+		[Address(RVA = "0x4093D0", Offset = "0x4081D0", VA = "0x1804093D0")]
+		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: 0x02000567 RID: 1383
+	[Token(Token = "0x2000567")]
+	[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: 0x040018AF RID: 6319
+		[Token(Token = "0x40018AF")]
+		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: 0x040018B0 RID: 6320
+		[Token(Token = "0x40018B0")]
+		InterfaceIsIUnknown,
+		/// <summary>Indicates that an interface is exposed to COM as a dispinterface, which enables late binding only.</summary>
+		// Token: 0x040018B1 RID: 6321
+		[Token(Token = "0x40018B1")]
+		InterfaceIsIDispatch,
+		/// <summary>Indicates that an interface is exposed to COM as a Windows Runtime interface.</summary>
+		// Token: 0x040018B2 RID: 6322
+		[Token(Token = "0x40018B2")]
+		[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: 0x0200059A RID: 1434
+	[Token(Token = "0x200059A")]
+	public struct FILETIME
+	{
+		/// <summary>Specifies the low 32 bits of the <see langword="FILETIME" />.</summary>
+		// Token: 0x0400194E RID: 6478
+		[FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x400194E")]
+		public int dwLowDateTime;
+
+		/// <summary>Specifies the high 32 bits of the <see langword="FILETIME" />.</summary>
+		// Token: 0x0400194F RID: 6479
+		[FieldOffset(Offset = "0x4")]
+		[Token(Token = "0x400194F")]
+		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: 0x0200059C RID: 1436
+	[Token(Token = "0x200059C")]
+	[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+	[Guid("0000000c-0000-0000-C000-000000000046")]
+	[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: 0x06002B39 RID: 11065
+		[Token(Token = "0x6002B39")]
+		[Address(RVA = "0x237A050", Offset = "0x2378E50", VA = "0x18237A050", 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: 0x06002B3A RID: 11066
+		[Token(Token = "0x6002B3A")]
+		[Address(RVA = "0x237A360", Offset = "0x2379160", VA = "0x18237A360", 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: 0x06002B3B RID: 11067
+		[Token(Token = "0x6002B3B")]
+		[Address(RVA = "0x237A150", Offset = "0x2378F50", VA = "0x18237A150", 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: 0x06002B3C RID: 11068
+		[Token(Token = "0x6002B3C")]
+		[Address(RVA = "0x237A1B0", Offset = "0x2378FB0", VA = "0x18237A1B0", 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: 0x06002B3D RID: 11069
+		[Token(Token = "0x6002B3D")]
+		[Address(RVA = "0x2379F40", Offset = "0x2378D40", VA = "0x182379F40", 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: 0x06002B3E RID: 11070
+		[Token(Token = "0x6002B3E")]
+		[Address(RVA = "0x2379F00", Offset = "0x2378D00", VA = "0x182379F00", 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: 0x06002B3F RID: 11071
+		[Token(Token = "0x6002B3F")]
+		[Address(RVA = "0x237A120", Offset = "0x2378F20", VA = "0x18237A120", 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: 0x06002B40 RID: 11072
+		[Token(Token = "0x6002B40")]
+		[Address(RVA = "0x2379FF0", Offset = "0x2378DF0", VA = "0x182379FF0", 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: 0x06002B41 RID: 11073
+		[Token(Token = "0x6002B41")]
+		[Address(RVA = "0x237A300", Offset = "0x2379100", VA = "0x18237A300", 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: 0x06002B42 RID: 11074
+		[Token(Token = "0x6002B42")]
+		[Address(RVA = "0x237A1F0", Offset = "0x2378FF0", VA = "0x18237A1F0", 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: 0x06002B43 RID: 11075
+		[Token(Token = "0x6002B43")]
+		[Address(RVA = "0x2379E40", Offset = "0x2378C40", VA = "0x182379E40", 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: 0x0200059B RID: 1435
+	[Token(Token = "0x200059B")]
+	[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: 0x04001950 RID: 6480
+		[FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x4001950")]
+		public string pwcsName;
+
+		/// <summary>Indicates the type of storage object, which is one of the values from the <see langword="STGTY" /> enumeration.</summary>
+		// Token: 0x04001951 RID: 6481
+		[FieldOffset(Offset = "0x8")]
+		[Token(Token = "0x4001951")]
+		public int type;
+
+		/// <summary>Specifies the size, in bytes, of the stream or byte array.</summary>
+		// Token: 0x04001952 RID: 6482
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x4001952")]
+		public long cbSize;
+
+		/// <summary>Indicates the last modification time for this storage, stream, or byte array.</summary>
+		// Token: 0x04001953 RID: 6483
+		[FieldOffset(Offset = "0x18")]
+		[Token(Token = "0x4001953")]
+		public FILETIME mtime;
+
+		/// <summary>Indicates the creation time for this storage, stream, or byte array.</summary>
+		// Token: 0x04001954 RID: 6484
+		[FieldOffset(Offset = "0x20")]
+		[Token(Token = "0x4001954")]
+		public FILETIME ctime;
+
+		/// <summary>Specifies the last access time for this storage, stream, or byte array.</summary>
+		// Token: 0x04001955 RID: 6485
+		[FieldOffset(Offset = "0x28")]
+		[Token(Token = "0x4001955")]
+		public FILETIME atime;
+
+		/// <summary>Indicates the access mode that was specified when the object was opened.</summary>
+		// Token: 0x04001956 RID: 6486
+		[FieldOffset(Offset = "0x30")]
+		[Token(Token = "0x4001956")]
+		public int grfMode;
+
+		/// <summary>Indicates the types of region locking supported by the stream or byte array.</summary>
+		// Token: 0x04001957 RID: 6487
+		[FieldOffset(Offset = "0x34")]
+		[Token(Token = "0x4001957")]
+		public int grfLocksSupported;
+
+		/// <summary>Indicates the class identifier for the storage object.</summary>
+		// Token: 0x04001958 RID: 6488
+		[FieldOffset(Offset = "0x38")]
+		[Token(Token = "0x4001958")]
+		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: 0x04001959 RID: 6489
+		[FieldOffset(Offset = "0x48")]
+		[Token(Token = "0x4001959")]
+		public int grfStateBits;
+
+		/// <summary>Reserved for future use.</summary>
+		// Token: 0x0400195A RID: 6490
+		[FieldOffset(Offset = "0x4C")]
+		[Token(Token = "0x400195A")]
+		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: 0x0200056C RID: 1388
+	[Token(Token = "0x200056C")]
+	[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: 0x06002A9A RID: 10906 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A9A")]
+		[Address(RVA = "0x49E320", Offset = "0x49D120", VA = "0x18049E320")]
+		public ComVisibleAttribute(bool visibility)
+		{
+		}
+
+		// Token: 0x040018BA RID: 6330
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x40018BA")]
+		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: 0x02000576 RID: 1398
+	[Token(Token = "0x2000576")]
+	[ComVisible(false)]
+	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Method)]
+	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: 0x06002AA2 RID: 10914 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AA2")]
+		[Address(RVA = "0x4D83A0", Offset = "0x4D71A0", VA = "0x1804D83A0")]
+		public DefaultDllImportSearchPathsAttribute(DllImportSearchPath paths)
+		{
+		}
+
+		// Token: 0x04001918 RID: 6424
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x4001918")]
+		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: 0x02000566 RID: 1382
+	[Token(Token = "0x2000566")]
+	[ComVisible(true)]
+	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event)]
+	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: 0x06002A96 RID: 10902 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A96")]
+		[Address(RVA = "0x4D83A0", Offset = "0x4D71A0", VA = "0x1804D83A0")]
+		public DispIdAttribute(int dispId)
+		{
+		}
+
+		// Token: 0x040018AD RID: 6317
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x40018AD")]
+		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: 0x02000577 RID: 1399
+	[Token(Token = "0x2000577")]
+	[ComVisible(true)]
+	[AttributeUsage(AttributeTargets.Method)]
+	public sealed class DllImportAttribute : Attribute
+	{
+		// Token: 0x06002AA3 RID: 10915 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002AA3")]
+		[Address(RVA = "0x2378820", Offset = "0x2377620", VA = "0x182378820")]
+		internal static Attribute GetCustomAttribute(RuntimeMethodInfo method)
+		{
+			return null;
+		}
+
+		// Token: 0x06002AA4 RID: 10916 RVA: 0x00016A10 File Offset: 0x00014C10
+		[Token(Token = "0x6002AA4")]
+		[Address(RVA = "0x2378AD0", Offset = "0x23778D0", VA = "0x182378AD0")]
+		internal static bool IsDefined(RuntimeMethodInfo method)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x06002AA5 RID: 10917 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AA5")]
+		[Address(RVA = "0x2378B00", Offset = "0x2377900", VA = "0x182378B00")]
+		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: 0x06002AA6 RID: 10918 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AA6")]
+		[Address(RVA = "0x462000", Offset = "0x460E00", VA = "0x180462000")]
+		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: 0x17000650 RID: 1616
+		// (get) Token: 0x06002AA7 RID: 10919 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x17000650")]
+		public string Value
+		{
+			[Token(Token = "0x6002AA7")]
+			[Address(RVA = "0x3F6E20", Offset = "0x3F5C20", VA = "0x1803F6E20")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x04001919 RID: 6425
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x4001919")]
+		internal string _val;
+
+		/// <summary>Indicates the name or ordinal of the DLL entry point to be called.</summary>
+		// Token: 0x0400191A RID: 6426
+		[FieldOffset(Offset = "0x18")]
+		[Token(Token = "0x400191A")]
+		public string EntryPoint;
+
+		/// <summary>Indicates how to marshal string parameters to the method and controls name mangling.</summary>
+		// Token: 0x0400191B RID: 6427
+		[FieldOffset(Offset = "0x20")]
+		[Token(Token = "0x400191B")]
+		public CharSet CharSet;
+
+		/// <summary>Indicates whether the callee calls the <see langword="SetLastError" /> Win32 API function before returning from the attributed method.</summary>
+		// Token: 0x0400191C RID: 6428
+		[FieldOffset(Offset = "0x24")]
+		[Token(Token = "0x400191C")]
+		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: 0x0400191D RID: 6429
+		[FieldOffset(Offset = "0x25")]
+		[Token(Token = "0x400191D")]
+		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: 0x0400191E RID: 6430
+		[FieldOffset(Offset = "0x26")]
+		[Token(Token = "0x400191E")]
+		public bool PreserveSig;
+
+		/// <summary>Indicates the calling convention of an entry point.</summary>
+		// Token: 0x0400191F RID: 6431
+		[FieldOffset(Offset = "0x28")]
+		[Token(Token = "0x400191F")]
+		public CallingConvention CallingConvention;
+
+		/// <summary>Enables or disables best-fit mapping behavior when converting Unicode characters to ANSI characters.</summary>
+		// Token: 0x04001920 RID: 6432
+		[FieldOffset(Offset = "0x2C")]
+		[Token(Token = "0x4001920")]
+		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: 0x04001921 RID: 6433
+		[FieldOffset(Offset = "0x2D")]
+		[Token(Token = "0x4001921")]
+		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: 0x02000575 RID: 1397
+	[Token(Token = "0x2000575")]
+	[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: 0x04001911 RID: 6417
+		[Token(Token = "0x4001911")]
+		UseDllDirectoryForDependencies = 256,
+		/// <summary>Include the application directory in the DLL search path.</summary>
+		// Token: 0x04001912 RID: 6418
+		[Token(Token = "0x4001912")]
+		ApplicationDirectory = 512,
+		/// <summary>Include any path that was explicitly added to the process-wide search path by using the Win32 AddDllDirectory function.</summary>
+		// Token: 0x04001913 RID: 6419
+		[Token(Token = "0x4001913")]
+		UserDirectories = 1024,
+		/// <summary>Include the <see langword="%WinDir%\System32" /> directory in the DLL search path.</summary>
+		// Token: 0x04001914 RID: 6420
+		[Token(Token = "0x4001914")]
+		System32 = 2048,
+		/// <summary>Include the application directory, the <see langword="%WinDir%\System32" /> directory, and user directories in the DLL search path.</summary>
+		// Token: 0x04001915 RID: 6421
+		[Token(Token = "0x4001915")]
+		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: 0x04001916 RID: 6422
+		[Token(Token = "0x4001916")]
+		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: 0x04001917 RID: 6423
+		[Token(Token = "0x4001917")]
+		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: 0x0200057D RID: 1405
+	[Token(Token = "0x200057D")]
+	[ComVisible(true)]
+	[Serializable]
+	public sealed class ErrorWrapper
+	{
+		// Token: 0x04001932 RID: 6450
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x4001932")]
+		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: 0x0200057E RID: 1406
+	[Token(Token = "0x200057E")]
+	[ComVisible(true)]
+	[Serializable]
+	public class ExternalException : SystemException
+	{
+		/// <summary>Initializes a new instance of the <see langword="ExternalException" /> class with default properties.</summary>
+		// Token: 0x06002AAE RID: 10926 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AAE")]
+		[Address(RVA = "0x2379900", Offset = "0x2378700", VA = "0x182379900")]
+		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: 0x06002AAF RID: 10927 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AAF")]
+		[Address(RVA = "0x2379990", Offset = "0x2378790", VA = "0x182379990")]
+		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: 0x06002AB0 RID: 10928 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AB0")]
+		[Address(RVA = "0x2379960", Offset = "0x2378760", VA = "0x182379960")]
+		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: 0x06002AB1 RID: 10929 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AB1")]
+		[Address(RVA = "0x23798D0", Offset = "0x23786D0", VA = "0x1823798D0")]
+		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: 0x06002AB2 RID: 10930 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AB2")]
+		[Address(RVA = "0x3F60E0", Offset = "0x3F4EE0", VA = "0x1803F60E0")]
+		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: 0x17000651 RID: 1617
+		// (get) Token: 0x06002AB3 RID: 10931 RVA: 0x00016A28 File Offset: 0x00014C28
+		[Token(Token = "0x17000651")]
+		public virtual int ErrorCode
+		{
+			[Token(Token = "0x6002AB3")]
+			[Address(RVA = "0xD17AD0", Offset = "0xD168D0", VA = "0x180D17AD0", 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: 0x06002AB4 RID: 10932 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002AB4")]
+		[Address(RVA = "0x2379730", Offset = "0x2378530", VA = "0x182379730", 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: 0x02000578 RID: 1400
+	[Token(Token = "0x2000578")]
+	[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: 0x06002AA8 RID: 10920 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AA8")]
+		[Address(RVA = "0x4D83A0", Offset = "0x4D71A0", VA = "0x1804D83A0")]
+		public FieldOffsetAttribute(int offset)
+		{
+		}
+
+		// Token: 0x04001922 RID: 6434
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x4001922")]
+		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: 0x02000586 RID: 1414
+	[Token(Token = "0x2000586")]
+	[MonoTODO]
+	[ComVisible(true)]
+	[MonoTODO("Struct should be [StructLayout(LayoutKind.Sequential)] but will need to be reordered for that.")]
+	public struct GCHandle
+	{
+		// Token: 0x06002AD5 RID: 10965 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AD5")]
+		[Address(RVA = "0x2379D70", Offset = "0x2378B70", VA = "0x182379D70")]
+		private GCHandle(IntPtr h)
+		{
+		}
+
+		// Token: 0x06002AD6 RID: 10966 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AD6")]
+		[Address(RVA = "0x2379D10", Offset = "0x2378B10", VA = "0x182379D10")]
+		private GCHandle(object obj)
+		{
+		}
+
+		// Token: 0x06002AD7 RID: 10967 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AD7")]
+		[Address(RVA = "0x2379D40", Offset = "0x2378B40", VA = "0x182379D40")]
+		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: 0x17000655 RID: 1621
+		// (get) Token: 0x06002AD8 RID: 10968 RVA: 0x00016A88 File Offset: 0x00014C88
+		[Token(Token = "0x17000655")]
+		public bool IsAllocated
+		{
+			[Token(Token = "0x6002AD8")]
+			[Address(RVA = "0x901960", Offset = "0x900760", VA = "0x180901960")]
+			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: 0x17000656 RID: 1622
+		// (get) Token: 0x06002AD9 RID: 10969 RVA: 0x00002082 File Offset: 0x00000282
+		// (set) Token: 0x06002ADA RID: 10970 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x17000656")]
+		public object Target
+		{
+			[Token(Token = "0x6002AD9")]
+			[Address(RVA = "0x2379D90", Offset = "0x2378B90", VA = "0x182379D90")]
+			get
+			{
+				return null;
+			}
+			[Token(Token = "0x6002ADA")]
+			[Address(RVA = "0x2379E10", Offset = "0x2378C10", VA = "0x182379E10")]
+			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: 0x06002ADB RID: 10971 RVA: 0x00016AA0 File Offset: 0x00014CA0
+		[Token(Token = "0x6002ADB")]
+		[Address(RVA = "0x23799D0", Offset = "0x23787D0", VA = "0x1823799D0")]
+		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: 0x06002ADC RID: 10972 RVA: 0x00016AB8 File Offset: 0x00014CB8
+		[Token(Token = "0x6002ADC")]
+		[Address(RVA = "0x2379AD0", Offset = "0x23788D0", VA = "0x182379AD0")]
+		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: 0x06002ADD RID: 10973 RVA: 0x00016AD0 File Offset: 0x00014CD0
+		[Token(Token = "0x6002ADD")]
+		[Address(RVA = "0x2379AB0", Offset = "0x23788B0", VA = "0x182379AB0")]
+		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: 0x06002ADE RID: 10974 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002ADE")]
+		[Address(RVA = "0x2379B80", Offset = "0x2378980", VA = "0x182379B80")]
+		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: 0x06002ADF RID: 10975 RVA: 0x00016AE8 File Offset: 0x00014CE8
+		[Token(Token = "0x6002ADF")]
+		[Address(RVA = "0x2379D00", Offset = "0x2378B00", VA = "0x182379D00")]
+		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: 0x06002AE0 RID: 10976 RVA: 0x00016B00 File Offset: 0x00014D00
+		[Token(Token = "0x6002AE0")]
+		[Address(RVA = "0x2379C10", Offset = "0x2378A10", VA = "0x182379C10")]
+		public static explicit operator GCHandle(IntPtr value)
+		{
+			return default(GCHandle);
+		}
+
+		// Token: 0x06002AE1 RID: 10977 RVA: 0x00016B18 File Offset: 0x00014D18
+		[Token(Token = "0x6002AE1")]
+		[Address(RVA = "0x2379AE0", Offset = "0x23788E0", VA = "0x182379AE0")]
+		private static bool CheckCurrentDomain(int handle)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x06002AE2 RID: 10978 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002AE2")]
+		[Address(RVA = "0x2379CF0", Offset = "0x2378AF0", VA = "0x182379CF0")]
+		private static object GetTarget(int handle)
+		{
+			return null;
+		}
+
+		// Token: 0x06002AE3 RID: 10979 RVA: 0x00016B30 File Offset: 0x00014D30
+		[Token(Token = "0x6002AE3")]
+		[Address(RVA = "0x2379CE0", Offset = "0x2378AE0", VA = "0x182379CE0")]
+		private static int GetTargetHandle(object obj, int handle, GCHandleType type)
+		{
+			return 0;
+		}
+
+		// Token: 0x06002AE4 RID: 10980 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AE4")]
+		[Address(RVA = "0x2379B70", Offset = "0x2378970", VA = "0x182379B70")]
+		private static void FreeHandle(int handle)
+		{
+		}
+
+		// Token: 0x06002AE5 RID: 10981 RVA: 0x00016B48 File Offset: 0x00014D48
+		[Token(Token = "0x6002AE5")]
+		[Address(RVA = "0x2379CD0", Offset = "0x2378AD0", VA = "0x182379CD0")]
+		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: 0x06002AE6 RID: 10982 RVA: 0x00016B60 File Offset: 0x00014D60
+		[Token(Token = "0x6002AE6")]
+		[Address(RVA = "0x164A970", Offset = "0x1649770", VA = "0x18164A970")]
+		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: 0x06002AE7 RID: 10983 RVA: 0x00016B78 File Offset: 0x00014D78
+		[Token(Token = "0x6002AE7")]
+		[Address(RVA = "0x2379AF0", Offset = "0x23788F0", VA = "0x182379AF0", 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: 0x06002AE8 RID: 10984 RVA: 0x00016B90 File Offset: 0x00014D90
+		[Token(Token = "0x6002AE8")]
+		[Address(RVA = "0x164A950", Offset = "0x1649750", VA = "0x18164A950", 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: 0x06002AE9 RID: 10985 RVA: 0x00016BA8 File Offset: 0x00014DA8
+		[Token(Token = "0x6002AE9")]
+		[Address(RVA = "0x2379C10", Offset = "0x2378A10", VA = "0x182379C10")]
+		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: 0x06002AEA RID: 10986 RVA: 0x00016BC0 File Offset: 0x00014DC0
+		[Token(Token = "0x6002AEA")]
+		[Address(RVA = "0x2379D00", Offset = "0x2378B00", VA = "0x182379D00")]
+		public static IntPtr ToIntPtr(GCHandle value)
+		{
+			return 0;
+		}
+
+		// Token: 0x0400193B RID: 6459
+		[FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x400193B")]
+		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: 0x02000587 RID: 1415
+	[Token(Token = "0x2000587")]
+	[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: 0x0400193D RID: 6461
+		[Token(Token = "0x400193D")]
+		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: 0x0400193E RID: 6462
+		[Token(Token = "0x400193E")]
+		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: 0x0400193F RID: 6463
+		[Token(Token = "0x400193F")]
+		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: 0x04001940 RID: 6464
+		[Token(Token = "0x4001940")]
+		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: 0x02000570 RID: 1392
+	[Token(Token = "0x2000570")]
+	[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: 0x06002A9C RID: 10908 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A9C")]
+		[Address(RVA = "0x462000", Offset = "0x460E00", VA = "0x180462000")]
+		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: 0x1700064F RID: 1615
+		// (get) Token: 0x06002A9D RID: 10909 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x1700064F")]
+		public string Value
+		{
+			[Token(Token = "0x6002A9D")]
+			[Address(RVA = "0x3F6E20", Offset = "0x3F5C20", VA = "0x1803F6E20")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x0400190F RID: 6415
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x400190F")]
+		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: 0x0200057F RID: 1407
+	[Token(Token = "0x200057F")]
+	[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: 0x06002AB5 RID: 10933 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AB5")]
+		[Address(RVA = "0x479F00", Offset = "0x478D00", VA = "0x180479F00")]
+		public HandleRef(object wrapper, IntPtr handle)
+		{
+		}
+
+		/// <summary>Gets the handle to a resource.</summary>
+		/// <returns>The handle to a resource.</returns>
+		// Token: 0x17000652 RID: 1618
+		// (get) Token: 0x06002AB6 RID: 10934 RVA: 0x00016A40 File Offset: 0x00014C40
+		[Token(Token = "0x17000652")]
+		public IntPtr Handle
+		{
+			[Token(Token = "0x6002AB6")]
+			[Address(RVA = "0x57C630", Offset = "0x57B430", VA = "0x18057C630")]
+			get
+			{
+				return 0;
+			}
+		}
+
+		// Token: 0x04001933 RID: 6451
+		[FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x4001933")]
+		internal object m_wrapper;
+
+		// Token: 0x04001934 RID: 6452
+		[FieldOffset(Offset = "0x8")]
+		[Token(Token = "0x4001934")]
+		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: 0x02000580 RID: 1408
+	[Token(Token = "0x2000580")]
+	[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: 0x06002AB7 RID: 10935
+		[Token(Token = "0x6002AB7")]
+		[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: 0x06002AB8 RID: 10936
+		[Token(Token = "0x6002AB8")]
+		[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: 0x06002AB9 RID: 10937
+		[Token(Token = "0x6002AB9")]
+		[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: 0x06002ABA RID: 10938
+		[Token(Token = "0x6002ABA")]
+		[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: 0x06002ABB RID: 10939
+		[Token(Token = "0x6002ABB")]
+		[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: 0x02000572 RID: 1394
+	[Token(Token = "0x2000572")]
+	[AttributeUsage(AttributeTargets.Parameter)]
+	[ComVisible(true)]
+	public sealed class InAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.InteropServices.InAttribute" /> class.</summary>
+		// Token: 0x06002A9F RID: 10911 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A9F")]
+		[Address(RVA = "0x4093D0", Offset = "0x4081D0", VA = "0x1804093D0")]
+		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: 0x02000568 RID: 1384
+	[Token(Token = "0x2000568")]
+	[AttributeUsage(AttributeTargets.Interface)]
+	[ComVisible(true)]
+	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: 0x06002A97 RID: 10903 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A97")]
+		[Address(RVA = "0x4D83A0", Offset = "0x4D71A0", VA = "0x1804D83A0")]
+		public InterfaceTypeAttribute(ComInterfaceType interfaceType)
+		{
+		}
+
+		// Token: 0x040018B3 RID: 6323
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x40018B3")]
+		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: 0x02000581 RID: 1409
+	[Token(Token = "0x2000581")]
+	[ComVisible(true)]
+	[Serializable]
+	public class InvalidComObjectException : SystemException
+	{
+		/// <summary>Initializes an instance of the <see langword="InvalidComObjectException" /> with default properties.</summary>
+		// Token: 0x06002ABC RID: 10940 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002ABC")]
+		[Address(RVA = "0x237AEC0", Offset = "0x2379CC0", VA = "0x18237AEC0")]
+		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: 0x06002ABD RID: 10941 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002ABD")]
+		[Address(RVA = "0x3F60E0", Offset = "0x3F4EE0", VA = "0x1803F60E0")]
+		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: 0x02000582 RID: 1410
+	[Token(Token = "0x2000582")]
+	[ComVisible(true)]
+	[Serializable]
+	public class InvalidOleVariantTypeException : SystemException
+	{
+		/// <summary>Initializes a new instance of the <see langword="InvalidOleVariantTypeException" /> class with default values.</summary>
+		// Token: 0x06002ABE RID: 10942 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002ABE")]
+		[Address(RVA = "0x237AF20", Offset = "0x2379D20", VA = "0x18237AF20")]
+		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: 0x06002ABF RID: 10943 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002ABF")]
+		[Address(RVA = "0x3F60E0", Offset = "0x3F4EE0", VA = "0x1803F60E0")]
+		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: 0x02000588 RID: 1416
+	[Token(Token = "0x2000588")]
+	public static class Marshal
+	{
+		// Token: 0x06002AEB RID: 10987 RVA: 0x00016BD8 File Offset: 0x00014DD8
+		[Token(Token = "0x6002AEB")]
+		[Address(RVA = "0x237DD80", Offset = "0x237CB80", VA = "0x18237DD80")]
+		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: 0x06002AEC RID: 10988 RVA: 0x00016BF0 File Offset: 0x00014DF0
+		[Token(Token = "0x6002AEC")]
+		[Address(RVA = "0x237DD90", Offset = "0x237CB90", VA = "0x18237DD90")]
+		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: 0x06002AED RID: 10989 RVA: 0x00016C08 File Offset: 0x00014E08
+		[Token(Token = "0x6002AED")]
+		[Address(RVA = "0x237DE30", Offset = "0x237CC30", VA = "0x18237DE30")]
+		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: 0x06002AEE RID: 10990 RVA: 0x00016C20 File Offset: 0x00014E20
+		[Token(Token = "0x6002AEE")]
+		[Address(RVA = "0x237DE40", Offset = "0x237CC40", VA = "0x18237DE40")]
+		[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: 0x06002AEF RID: 10991 RVA: 0x00016C38 File Offset: 0x00014E38
+		[Token(Token = "0x6002AEF")]
+		[Address(RVA = "0x237DE50", Offset = "0x237CC50", VA = "0x18237DE50")]
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
+		public static IntPtr AllocHGlobal(int cb)
+		{
+			return 0;
+		}
+
+		// Token: 0x06002AF0 RID: 10992 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AF0")]
+		[Address(RVA = "0x23805D0", Offset = "0x237F3D0", VA = "0x1823805D0")]
+		internal static void copy_to_unmanaged(Array source, int startIndex, IntPtr destination, int length)
+		{
+		}
+
+		// Token: 0x06002AF1 RID: 10993 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AF1")]
+		[Address(RVA = "0x23805C0", Offset = "0x237F3C0", VA = "0x1823805C0")]
+		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: 0x06002AF2 RID: 10994 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AF2")]
+		[Address(RVA = "0x237ECE0", Offset = "0x237DAE0", VA = "0x18237ECE0")]
+		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: 0x06002AF3 RID: 10995 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AF3")]
+		[Address(RVA = "0x237EEE0", Offset = "0x237DCE0", VA = "0x18237EEE0")]
+		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: 0x06002AF4 RID: 10996 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AF4")]
+		[Address(RVA = "0x237EE60", Offset = "0x237DC60", VA = "0x18237EE60")]
+		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: 0x06002AF5 RID: 10997 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AF5")]
+		[Address(RVA = "0x237EDE0", Offset = "0x237DBE0", VA = "0x18237EDE0")]
+		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: 0x06002AF6 RID: 10998 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AF6")]
+		[Address(RVA = "0x237EF60", Offset = "0x237DD60", VA = "0x18237EF60")]
+		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: 0x06002AF7 RID: 10999 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AF7")]
+		[Address(RVA = "0x237ED60", Offset = "0x237DB60", VA = "0x18237ED60")]
+		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: 0x06002AF8 RID: 11000 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AF8")]
+		[Address(RVA = "0x237EFE0", Offset = "0x237DDE0", VA = "0x18237EFE0")]
+		[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: 0x06002AF9 RID: 11001 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AF9")]
+		[Address(RVA = "0x237EFF0", Offset = "0x237DDF0", VA = "0x18237EFF0")]
+		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: 0x06002AFA RID: 11002 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AFA")]
+		[Address(RVA = "0x237F000", Offset = "0x237DE00", VA = "0x18237F000")]
+		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: 0x06002AFB RID: 11003 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AFB")]
+		[Address(RVA = "0x237F010", Offset = "0x237DE10", VA = "0x18237F010")]
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
+		public static void FreeHGlobal(IntPtr hglobal)
+		{
+		}
+
+		// Token: 0x06002AFC RID: 11004 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AFC")]
+		[Address(RVA = "0x237DEB0", Offset = "0x237CCB0", VA = "0x18237DEB0")]
+		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: 0x06002AFD RID: 11005 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AFD")]
+		[Address(RVA = "0x23802D0", Offset = "0x237F0D0", VA = "0x1823802D0")]
+		public static void ZeroFreeBSTR(IntPtr s)
+		{
+		}
+
+		// Token: 0x06002AFE RID: 11006 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AFE")]
+		[Address(RVA = "0x237DF90", Offset = "0x237CD90", VA = "0x18237DF90")]
+		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: 0x06002AFF RID: 11007 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AFF")]
+		[Address(RVA = "0x2380400", Offset = "0x237F200", VA = "0x182380400")]
+		public static void ZeroFreeGlobalAllocUnicode(IntPtr s)
+		{
+		}
+
+		// Token: 0x06002B00 RID: 11008 RVA: 0x00016C50 File Offset: 0x00014E50
+		[Token(Token = "0x6002B00")]
+		[Address(RVA = "0x237F020", Offset = "0x237DE20", VA = "0x18237F020")]
+		private static IntPtr GetCCW(object o, Type T)
+		{
+			return 0;
+		}
+
+		// Token: 0x06002B01 RID: 11009 RVA: 0x00016C68 File Offset: 0x00014E68
+		[Token(Token = "0x6002B01")]
+		[Address(RVA = "0x237F030", Offset = "0x237DE30", VA = "0x18237F030")]
+		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: 0x06002B02 RID: 11010 RVA: 0x00016C80 File Offset: 0x00014E80
+		[Token(Token = "0x6002B02")]
+		[Address(RVA = "0x237F090", Offset = "0x237DE90", VA = "0x18237F090")]
+		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: 0x06002B03 RID: 11011 RVA: 0x00016C98 File Offset: 0x00014E98
+		[Token(Token = "0x6002B03")]
+		[Address(RVA = "0x237F500", Offset = "0x237E300", VA = "0x18237F500")]
+		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: 0x06002B04 RID: 11012 RVA: 0x00016CB0 File Offset: 0x00014EB0
+		[Token(Token = "0x6002B04")]
+		[Address(RVA = "0x237F510", Offset = "0x237E310", VA = "0x18237F510")]
+		[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: 0x06002B05 RID: 11013 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002B05")]
+		[Address(RVA = "0x237F520", Offset = "0x237E320", VA = "0x18237F520")]
+		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: 0x06002B06 RID: 11014 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002B06")]
+		[Address(RVA = "0x237F540", Offset = "0x237E340", VA = "0x18237F540")]
+		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: 0x06002B07 RID: 11015 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002B07")]
+		[Address(RVA = "0x237F530", Offset = "0x237E330", VA = "0x18237F530")]
+		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: 0x06002B08 RID: 11016 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002B08")]
+		[Address(RVA = "0x237F550", Offset = "0x237E350", VA = "0x18237F550")]
+		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: 0x06002B09 RID: 11017 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002B09")]
+		[Address(RVA = "0x237F600", Offset = "0x237E400", VA = "0x18237F600")]
+		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: 0x06002B0A RID: 11018 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002B0A")]
+		[Address(RVA = "0x237F5F0", Offset = "0x237E3F0", VA = "0x18237F5F0")]
+		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: 0x06002B0B RID: 11019 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002B0B")]
+		[Address(RVA = "0x237F610", Offset = "0x237E410", VA = "0x18237F610")]
+		[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: 0x06002B0C RID: 11020 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002B0C")]
+		[Address(RVA = "0x237F620", Offset = "0x237E420", VA = "0x18237F620")]
+		[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: 0x06002B0D RID: 11021 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002B0D")]
+		[Address(RVA = "0x16D2C80", Offset = "0x16D1A80", VA = "0x1816D2C80")]
+		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: 0x06002B0E RID: 11022 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002B0E")]
+		[Address(RVA = "0x1299A10", Offset = "0x1298810", VA = "0x181299A10")]
+		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: 0x06002B0F RID: 11023 RVA: 0x00016CC8 File Offset: 0x00014EC8
+		[Token(Token = "0x6002B0F")]
+		[Address(RVA = "0x237F630", Offset = "0x237E430", VA = "0x18237F630")]
+		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: 0x06002B10 RID: 11024 RVA: 0x00016CE0 File Offset: 0x00014EE0
+		[Token(Token = "0x6002B10")]
+		[Address(RVA = "0x237F650", Offset = "0x237E450", VA = "0x18237F650")]
+		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: 0x06002B11 RID: 11025 RVA: 0x00016CF8 File Offset: 0x00014EF8
+		[Token(Token = "0x6002B11")]
+		[Address(RVA = "0x237F6A0", Offset = "0x237E4A0", VA = "0x18237F6A0")]
+		[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: 0x06002B12 RID: 11026 RVA: 0x00016D10 File Offset: 0x00014F10
+		[Token(Token = "0x6002B12")]
+		[Address(RVA = "0x237F6E0", Offset = "0x237E4E0", VA = "0x18237F6E0")]
+		[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: 0x06002B13 RID: 11027 RVA: 0x00016D28 File Offset: 0x00014F28
+		[Token(Token = "0x6002B13")]
+		[Address(RVA = "0x237F780", Offset = "0x237E580", VA = "0x18237F780")]
+		[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: 0x06002B14 RID: 11028 RVA: 0x00016D40 File Offset: 0x00014F40
+		[Token(Token = "0x6002B14")]
+		[Address(RVA = "0x237F730", Offset = "0x237E530", VA = "0x18237F730")]
+		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: 0x06002B15 RID: 11029 RVA: 0x00016D58 File Offset: 0x00014F58
+		[Token(Token = "0x6002B15")]
+		[Address(RVA = "0x237F8F0", Offset = "0x237E6F0", VA = "0x18237F8F0")]
+		[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: 0x06002B16 RID: 11030 RVA: 0x00016D70 File Offset: 0x00014F70
+		[Token(Token = "0x6002B16")]
+		[Address(RVA = "0x237F7D0", Offset = "0x237E5D0", VA = "0x18237F7D0")]
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
+		public static IntPtr ReadIntPtr(IntPtr ptr, int ofs)
+		{
+			return 0;
+		}
+
+		// Token: 0x06002B17 RID: 11031 RVA: 0x00016D88 File Offset: 0x00014F88
+		[Token(Token = "0x6002B17")]
+		[Address(RVA = "0x237FA00", Offset = "0x237E800", VA = "0x18237FA00")]
+		[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: 0x06002B18 RID: 11032 RVA: 0x00016DA0 File Offset: 0x00014FA0
+		[Token(Token = "0x6002B18")]
+		[Address(RVA = "0x237FA10", Offset = "0x237E810", VA = "0x18237FA10")]
+		[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: 0x06002B19 RID: 11033 RVA: 0x00016DB8 File Offset: 0x00014FB8
+		[Token(Token = "0x6002B19")]
+		[Address(RVA = "0x237FF20", Offset = "0x237ED20", VA = "0x18237FF20")]
+		[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: 0x06002B1A RID: 11034 RVA: 0x00016DD0 File Offset: 0x00014FD0
+		[Token(Token = "0x6002B1A")]
+		[Address(RVA = "0x237FF10", Offset = "0x237ED10", VA = "0x18237FF10")]
+		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: 0x06002B1B RID: 11035 RVA: 0x00016DE8 File Offset: 0x00014FE8
+		[Token(Token = "0x6002B1B")]
+		[Address(RVA = "0x2174D70", Offset = "0x2173B70", VA = "0x182174D70")]
+		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: 0x06002B1C RID: 11036 RVA: 0x00016E00 File Offset: 0x00015000
+		[Token(Token = "0x6002B1C")]
+		[Address(RVA = "0x2174E00", Offset = "0x2173C00", VA = "0x182174E00")]
+		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: 0x06002B1D RID: 11037 RVA: 0x00016E18 File Offset: 0x00015018
+		[Token(Token = "0x6002B1D")]
+		[Address(RVA = "0x237FF90", Offset = "0x237ED90", VA = "0x18237FF90")]
+		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: 0x06002B1E RID: 11038 RVA: 0x00016E30 File Offset: 0x00015030
+		[Token(Token = "0x6002B1E")]
+		[Address(RVA = "0x237FFA0", Offset = "0x237EDA0", VA = "0x18237FFA0")]
+		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: 0x06002B1F RID: 11039 RVA: 0x00016E48 File Offset: 0x00015048
+		[Token(Token = "0x6002B1F")]
+		[Address(RVA = "0x237FAB0", Offset = "0x237E8B0", VA = "0x18237FAB0")]
+		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: 0x06002B20 RID: 11040 RVA: 0x00016E60 File Offset: 0x00015060
+		[Token(Token = "0x6002B20")]
+		[Address(RVA = "0x237FC20", Offset = "0x237EA20", VA = "0x18237FC20")]
+		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: 0x06002B21 RID: 11041 RVA: 0x00016E78 File Offset: 0x00015078
+		[Token(Token = "0x6002B21")]
+		[Address(RVA = "0x237FE80", Offset = "0x237EC80", VA = "0x18237FE80")]
+		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: 0x06002B22 RID: 11042 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002B22")]
+		[Address(RVA = "0x237FFB0", Offset = "0x237EDB0", VA = "0x18237FFB0")]
+		[ComVisible(true)]
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
+		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: 0x06002B23 RID: 11043 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002B23")]
+		[Address(RVA = "0x16D2CF0", Offset = "0x16D1AF0", VA = "0x1816D2CF0")]
+		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: 0x06002B24 RID: 11044 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002B24")]
+		[Address(RVA = "0x237FFC0", Offset = "0x237EDC0", VA = "0x18237FFC0")]
+		public static void ThrowExceptionForHR(int errorCode)
+		{
+		}
+
+		// Token: 0x06002B25 RID: 11045 RVA: 0x00016E90 File Offset: 0x00015090
+		[Token(Token = "0x6002B25")]
+		[Address(RVA = "0x450D90", Offset = "0x44FB90", VA = "0x180450D90")]
+		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: 0x06002B26 RID: 11046 RVA: 0x00016EA8 File Offset: 0x000150A8
+		[Token(Token = "0x6002B26")]
+		[Address(RVA = "0x23800B0", Offset = "0x237EEB0", VA = "0x1823800B0")]
+		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: 0x06002B27 RID: 11047 RVA: 0x00016EC0 File Offset: 0x000150C0
+		[Token(Token = "0x6002B27")]
+		[Address(RVA = "0x21754C0", Offset = "0x21742C0", VA = "0x1821754C0")]
+		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: 0x06002B28 RID: 11048 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002B28")]
+		[Address(RVA = "0x23800C0", Offset = "0x237EEC0", VA = "0x1823800C0")]
+		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: 0x06002B29 RID: 11049 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002B29")]
+		[Address(RVA = "0x23800F0", Offset = "0x237EEF0", VA = "0x1823800F0")]
+		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: 0x06002B2A RID: 11050 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002B2A")]
+		[Address(RVA = "0x2380140", Offset = "0x237EF40", VA = "0x182380140")]
+		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: 0x06002B2B RID: 11051 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002B2B")]
+		[Address(RVA = "0x2380180", Offset = "0x237EF80", VA = "0x182380180")]
+		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: 0x06002B2C RID: 11052 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002B2C")]
+		[Address(RVA = "0x23801C0", Offset = "0x237EFC0", VA = "0x1823801C0")]
+		public static void WriteIntPtr(IntPtr ptr, IntPtr val)
+		{
+		}
+
+		// Token: 0x06002B2D RID: 11053 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002B2D")]
+		[Address(RVA = "0x237E0A0", Offset = "0x237CEA0", VA = "0x18237E0A0")]
+		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: 0x06002B2E RID: 11054 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002B2E")]
+		[Address(RVA = "0x237F460", Offset = "0x237E260", VA = "0x18237F460")]
+		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: 0x06002B2F RID: 11055 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002B2F")]
+		[Address(RVA = "0x237F410", Offset = "0x237E210", VA = "0x18237F410")]
+		public static Exception GetExceptionForHR(int errorCode, IntPtr errorInfo)
+		{
+			return null;
+		}
+
+		// Token: 0x06002B30 RID: 11056 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002B30")]
+		[Address(RVA = "0x237F1C0", Offset = "0x237DFC0", VA = "0x18237F1C0")]
+		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: 0x06002B31 RID: 11057 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002B31")]
+		[Address(RVA = "0x237F1D0", Offset = "0x237DFD0", VA = "0x18237F1D0")]
+		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: 0x06002B32 RID: 11058 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002B32")]
+		[Address(RVA = "0x239CDC0", Offset = "0x239BBC0", VA = "0x18239CDC0")]
+		public static TDelegate GetDelegateForFunctionPointer<TDelegate>(IntPtr ptr)
+		{
+			return null;
+		}
+
+		// Token: 0x06002B33 RID: 11059 RVA: 0x00016ED8 File Offset: 0x000150D8
+		[Token(Token = "0x6002B33")]
+		[Address(RVA = "0x237F4F0", Offset = "0x237E2F0", VA = "0x18237F4F0")]
+		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: 0x06002B34 RID: 11060 RVA: 0x00016EF0 File Offset: 0x000150F0
+		[Token(Token = "0x6002B34")]
+		[Address(RVA = "0x2174CB0", Offset = "0x2173AB0", VA = "0x182174CB0")]
+		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: 0x04001941 RID: 6465
+		[Token(Token = "0x4001941")]
+		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: 0x04001942 RID: 6466
+		[Token(Token = "0x4001942")]
+		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: 0x02000589 RID: 1417
+	[Token(Token = "0x2000589")]
+	[ComVisible(true)]
+	[AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue)]
+	[StructLayout(0)]
+	public sealed class MarshalAsAttribute : Attribute
+	{
+		// Token: 0x06002B36 RID: 11062 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6002B36")]
+		[Address(RVA = "0x237DC90", Offset = "0x237CA90", VA = "0x18237DC90")]
+		internal MarshalAsAttribute Copy()
+		{
+			return null;
+		}
+
+		/// <summary>Provides additional information to a custom marshaler.</summary>
+		// Token: 0x04001943 RID: 6467
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x4001943")]
+		public string MarshalCookie;
+
+		/// <summary>Specifies the fully qualified name of a custom marshaler.</summary>
+		// Token: 0x04001944 RID: 6468
+		[FieldOffset(Offset = "0x18")]
+		[Token(Token = "0x4001944")]
+		[ComVisible(true)]
+		public string MarshalType;
+
+		/// <summary>Implements <see cref="F:System.Runtime.InteropServices.MarshalAsAttribute.MarshalType" /> as a type.</summary>
+		// Token: 0x04001945 RID: 6469
+		[FieldOffset(Offset = "0x20")]
+		[Token(Token = "0x4001945")]
+		[ComVisible(true)]
+		public Type MarshalTypeRef;
+
+		/// <summary>Indicates the user-defined element type of the <see cref="F:System.Runtime.InteropServices.UnmanagedType.SafeArray" />.</summary>
+		// Token: 0x04001946 RID: 6470
+		[FieldOffset(Offset = "0x28")]
+		[Token(Token = "0x4001946")]
+		public Type SafeArrayUserDefinedSubType;
+
+		// Token: 0x04001947 RID: 6471
+		[FieldOffset(Offset = "0x30")]
+		[Token(Token = "0x4001947")]
+		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: 0x04001948 RID: 6472
+		[FieldOffset(Offset = "0x34")]
+		[Token(Token = "0x4001948")]
+		public UnmanagedType ArraySubType;
+
+		/// <summary>Indicates the element type of the <see cref="F:System.Runtime.InteropServices.UnmanagedType.SafeArray" />.</summary>
+		// Token: 0x04001949 RID: 6473
+		[FieldOffset(Offset = "0x38")]
+		[Token(Token = "0x4001949")]
+		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: 0x0400194A RID: 6474
+		[FieldOffset(Offset = "0x3C")]
+		[Token(Token = "0x400194A")]
+		public int SizeConst;
+
+		/// <summary>Specifies the parameter index of the unmanaged <see langword="iid_is" /> attribute used by COM.</summary>
+		// Token: 0x0400194B RID: 6475
+		[FieldOffset(Offset = "0x40")]
+		[Token(Token = "0x400194B")]
+		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: 0x0400194C RID: 6476
+		[FieldOffset(Offset = "0x44")]
+		[Token(Token = "0x400194C")]
+		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: 0x02000583 RID: 1411
+	[Token(Token = "0x2000583")]
+	[ComVisible(true)]
+	[Serializable]
+	public class MarshalDirectiveException : SystemException
+	{
+		/// <summary>Initializes a new instance of the <see langword="MarshalDirectiveException" /> class with default properties.</summary>
+		// Token: 0x06002AC0 RID: 10944 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AC0")]
+		[Address(RVA = "0x237DCF0", Offset = "0x237CAF0", VA = "0x18237DCF0")]
+		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: 0x06002AC1 RID: 10945 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AC1")]
+		[Address(RVA = "0x237DD50", Offset = "0x237CB50", VA = "0x18237DD50")]
+		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: 0x06002AC2 RID: 10946 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AC2")]
+		[Address(RVA = "0x3F60E0", Offset = "0x3F4EE0", VA = "0x1803F60E0")]
+		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: 0x02000574 RID: 1396
+	[Token(Token = "0x2000574")]
+	[AttributeUsage(AttributeTargets.Parameter)]
+	[ComVisible(true)]
+	public sealed class OptionalAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see langword="OptionalAttribute" /> class with default values.</summary>
+		// Token: 0x06002AA1 RID: 10913 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AA1")]
+		[Address(RVA = "0x4093D0", Offset = "0x4081D0", VA = "0x1804093D0")]
+		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: 0x02000573 RID: 1395
+	[Token(Token = "0x2000573")]
+	[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: 0x06002AA0 RID: 10912 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AA0")]
+		[Address(RVA = "0x4093D0", Offset = "0x4081D0", VA = "0x1804093D0")]
+		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: 0x02000571 RID: 1393
+	[Token(Token = "0x2000571")]
+	[ComVisible(true)]
+	[AttributeUsage(AttributeTargets.Method)]
+	public sealed class PreserveSigAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.InteropServices.PreserveSigAttribute" /> class.</summary>
+		// Token: 0x06002A9E RID: 10910 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A9E")]
+		[Address(RVA = "0x4093D0", Offset = "0x4081D0", VA = "0x1804093D0")]
+		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: 0x02000584 RID: 1412
+	[Token(Token = "0x2000584")]
+	[ComVisible(true)]
+	[Serializable]
+	public class SafeArrayTypeMismatchException : SystemException
+	{
+		/// <summary>Initializes a new instance of the <see langword="SafeArrayTypeMismatchException" /> class with default values.</summary>
+		// Token: 0x06002AC3 RID: 10947 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AC3")]
+		[Address(RVA = "0x2382120", Offset = "0x2380F20", VA = "0x182382120")]
+		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: 0x06002AC4 RID: 10948 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AC4")]
+		[Address(RVA = "0x3F60E0", Offset = "0x3F4EE0", VA = "0x1803F60E0")]
+		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: 0x0200058A RID: 1418
+	[Token(Token = "0x200058A")]
+	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: 0x06002B37 RID: 11063 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002B37")]
+		[Address(RVA = "0x2382180", Offset = "0x2380F80", VA = "0x182382180")]
+		[CLSCompliant(false)]
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
+		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: 0x06002B38 RID: 11064 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002B38")]
+		[Address(RVA = "0x2382210", Offset = "0x2381010", VA = "0x182382210")]
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
+		public void ReleasePointer()
+		{
+		}
+
+		// Token: 0x0400194D RID: 6477
+		[FieldOffset(Offset = "0x20")]
+		[Token(Token = "0x400194D")]
+		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: 0x02000585 RID: 1413
+	[Token(Token = "0x2000585")]
+	[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: 0x06002AC5 RID: 10949 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AC5")]
+		[Address(RVA = "0x2382810", Offset = "0x2381610", VA = "0x182382810")]
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
+		protected SafeHandle(IntPtr invalidHandleValue, bool ownsHandle)
+		{
+		}
+
+		/// <summary>Frees all resources associated with the handle.</summary>
+		// Token: 0x06002AC6 RID: 10950 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AC6")]
+		[Address(RVA = "0x2382610", Offset = "0x2381410", VA = "0x182382610", 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: 0x06002AC7 RID: 10951 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AC7")]
+		[Address(RVA = "0x3F7200", Offset = "0x3F6000", VA = "0x1803F7200")]
+		[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: 0x06002AC8 RID: 10952 RVA: 0x00016A58 File Offset: 0x00014C58
+		[Token(Token = "0x6002AC8")]
+		[Address(RVA = "0x3F6E20", Offset = "0x3F5C20", VA = "0x1803F6E20")]
+		[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: 0x17000653 RID: 1619
+		// (get) Token: 0x06002AC9 RID: 10953 RVA: 0x00016A70 File Offset: 0x00014C70
+		[Token(Token = "0x17000653")]
+		public bool IsClosed
+		{
+			[Token(Token = "0x6002AC9")]
+			[Address(RVA = "0x23828A0", Offset = "0x23816A0", VA = "0x1823828A0")]
+			[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: 0x17000654 RID: 1620
+		// (get) Token: 0x06002ACA RID: 10954
+		[Token(Token = "0x17000654")]
+		public abstract bool IsInvalid
+		{
+			[Token(Token = "0x6002ACA")]
+			[Address(Slot = "5")]
+			[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
+			get;
+		}
+
+		/// <summary>Marks the handle for releasing and freeing resources.</summary>
+		// Token: 0x06002ACB RID: 10955 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002ACB")]
+		[Address(RVA = "0x2382280", Offset = "0x2381080", VA = "0x182382280")]
+		[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: 0x06002ACC RID: 10956 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002ACC")]
+		[Address(RVA = "0x2382280", Offset = "0x2381080", VA = "0x182382280", 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: 0x06002ACD RID: 10957 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002ACD")]
+		[Address(RVA = "0x2382560", Offset = "0x2381360", VA = "0x182382560", 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: 0x06002ACE RID: 10958
+		[Token(Token = "0x6002ACE")]
+		[Address(Slot = "7")]
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
+		protected abstract bool ReleaseHandle();
+
+		/// <summary>Marks a handle as no longer used.</summary>
+		// Token: 0x06002ACF RID: 10959 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002ACF")]
+		[Address(RVA = "0x2382740", Offset = "0x2381540", VA = "0x182382740")]
+		[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: 0x06002AD0 RID: 10960 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AD0")]
+		[Address(RVA = "0x23822A0", Offset = "0x23810A0", VA = "0x1823822A0")]
+		[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: 0x06002AD1 RID: 10961 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AD1")]
+		[Address(RVA = "0x2382550", Offset = "0x2381350", VA = "0x182382550")]
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
+		public void DangerousRelease()
+		{
+		}
+
+		// Token: 0x06002AD2 RID: 10962 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AD2")]
+		[Address(RVA = "0x2382690", Offset = "0x2381490", VA = "0x182382690")]
+		private void InternalDispose()
+		{
+		}
+
+		// Token: 0x06002AD3 RID: 10963 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AD3")]
+		[Address(RVA = "0x2382720", Offset = "0x2381520", VA = "0x182382720")]
+		private void InternalFinalize()
+		{
+		}
+
+		// Token: 0x06002AD4 RID: 10964 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002AD4")]
+		[Address(RVA = "0x23823B0", Offset = "0x23811B0", VA = "0x1823823B0")]
+		private void DangerousReleaseInternal(bool dispose)
+		{
+		}
+
+		/// <summary>Specifies the handle to be wrapped.</summary>
+		// Token: 0x04001935 RID: 6453
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x4001935")]
+		protected IntPtr handle;
+
+		// Token: 0x04001936 RID: 6454
+		[FieldOffset(Offset = "0x18")]
+		[Token(Token = "0x4001936")]
+		private int _state;
+
+		// Token: 0x04001937 RID: 6455
+		[FieldOffset(Offset = "0x1C")]
+		[Token(Token = "0x4001937")]
+		private bool _ownsHandle;
+
+		// Token: 0x04001938 RID: 6456
+		[FieldOffset(Offset = "0x1D")]
+		[Token(Token = "0x4001938")]
+		private bool _fullyInitialized;
+
+		// Token: 0x04001939 RID: 6457
+		[Token(Token = "0x4001939")]
+		private const int RefCount_Mask = 2147483644;
+
+		// Token: 0x0400193A RID: 6458
+		[Token(Token = "0x400193A")]
+		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: 0x02000565 RID: 1381
+	[Token(Token = "0x2000565")]
+	[ComVisible(true)]
+	[AttributeUsage(AttributeTargets.Delegate)]
+	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: 0x06002A95 RID: 10901 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6002A95")]
+		[Address(RVA = "0x4D83A0", Offset = "0x4D71A0", VA = "0x1804D83A0")]
+		public UnmanagedFunctionPointerAttribute(CallingConvention callingConvention)
+		{
+		}
+
+		// Token: 0x040018A8 RID: 6312
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x40018A8")]
+		private CallingConvention m_callingConvention;
+
+		/// <summary>Indicates how to marshal string parameters to the method, and controls name mangling.</summary>
+		// Token: 0x040018A9 RID: 6313
+		[FieldOffset(Offset = "0x14")]
+		[Token(Token = "0x40018A9")]
+		public CharSet CharSet;
+
+		/// <summary>Enables or disables best-fit mapping behavior when converting Unicode characters to ANSI characters.</summary>
+		// Token: 0x040018AA RID: 6314
+		[FieldOffset(Offset = "0x18")]
+		[Token(Token = "0x40018AA")]
+		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: 0x040018AB RID: 6315
+		[FieldOffset(Offset = "0x19")]
+		[Token(Token = "0x40018AB")]
+		public bool ThrowOnUnmappableChar;
+
+		/// <summary>Indicates whether the callee calls the <see langword="SetLastError" /> Win32 API function before returning from the attributed method.</summary>
+		// Token: 0x040018AC RID: 6316
+		[FieldOffset(Offset = "0x1A")]
+		[Token(Token = "0x40018AC")]
+		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: 0x0200056E RID: 1390
+	[Token(Token = "0x200056E")]
+	[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: 0x040018E9 RID: 6377
+		[Token(Token = "0x40018E9")]
+		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: 0x040018EA RID: 6378
+		[Token(Token = "0x40018EA")]
+		I1,
+		/// <summary>A 1-byte unsigned integer.</summary>
+		// Token: 0x040018EB RID: 6379
+		[Token(Token = "0x40018EB")]
+		U1,
+		/// <summary>A 2-byte signed integer.</summary>
+		// Token: 0x040018EC RID: 6380
+		[Token(Token = "0x40018EC")]
+		I2,
+		/// <summary>A 2-byte unsigned integer.</summary>
+		// Token: 0x040018ED RID: 6381
+		[Token(Token = "0x40018ED")]
+		U2,
+		/// <summary>A 4-byte signed integer.</summary>
+		// Token: 0x040018EE RID: 6382
+		[Token(Token = "0x40018EE")]
+		I4,
+		/// <summary>A 4-byte unsigned integer.</summary>
+		// Token: 0x040018EF RID: 6383
+		[Token(Token = "0x40018EF")]
+		U4,
+		/// <summary>An 8-byte signed integer.</summary>
+		// Token: 0x040018F0 RID: 6384
+		[Token(Token = "0x40018F0")]
+		I8,
+		/// <summary>An 8-byte unsigned integer.</summary>
+		// Token: 0x040018F1 RID: 6385
+		[Token(Token = "0x40018F1")]
+		U8,
+		/// <summary>A 4-byte floating-point number.</summary>
+		// Token: 0x040018F2 RID: 6386
+		[Token(Token = "0x40018F2")]
+		R4,
+		/// <summary>An 8-byte floating-point number.</summary>
+		// Token: 0x040018F3 RID: 6387
+		[Token(Token = "0x40018F3")]
+		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: 0x040018F4 RID: 6388
+		[Token(Token = "0x40018F4")]
+		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: 0x040018F5 RID: 6389
+		[Token(Token = "0x40018F5")]
+		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: 0x040018F6 RID: 6390
+		[Token(Token = "0x40018F6")]
+		LPStr,
+		/// <summary>A 2-byte, null-terminated Unicode character string.</summary>
+		// Token: 0x040018F7 RID: 6391
+		[Token(Token = "0x40018F7")]
+		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: 0x040018F8 RID: 6392
+		[Token(Token = "0x40018F8")]
+		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: 0x040018F9 RID: 6393
+		[Token(Token = "0x40018F9")]
+		ByValTStr,
+		/// <summary>A COM <see langword="IUnknown" /> pointer. You can use this member on the <see cref="T:System.Object" /> data type.</summary>
+		// Token: 0x040018FA RID: 6394
+		[Token(Token = "0x40018FA")]
+		IUnknown = 25,
+		/// <summary>A COM <see langword="IDispatch" /> pointer (<see langword="Object" /> in Microsoft Visual Basic 6.0).</summary>
+		// Token: 0x040018FB RID: 6395
+		[Token(Token = "0x40018FB")]
+		IDispatch,
+		/// <summary>A VARIANT, which is used to marshal managed formatted classes and value types.</summary>
+		// Token: 0x040018FC RID: 6396
+		[Token(Token = "0x40018FC")]
+		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: 0x040018FD RID: 6397
+		[Token(Token = "0x40018FD")]
+		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: 0x040018FE RID: 6398
+		[Token(Token = "0x40018FE")]
+		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: 0x040018FF RID: 6399
+		[Token(Token = "0x40018FF")]
+		ByValArray,
+		/// <summary>A platform-dependent, signed integer: 4 bytes on 32-bit Windows, 8 bytes on 64-bit Windows.</summary>
+		// Token: 0x04001900 RID: 6400
+		[Token(Token = "0x4001900")]
+		SysInt,
+		/// <summary>A platform-dependent, unsigned integer: 4 bytes on 32-bit Windows, 8 bytes on 64-bit Windows.</summary>
+		// Token: 0x04001901 RID: 6401
+		[Token(Token = "0x4001901")]
+		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: 0x04001902 RID: 6402
+		[Token(Token = "0x4001902")]
+		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: 0x04001903 RID: 6403
+		[Token(Token = "0x4001903")]
+		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: 0x04001904 RID: 6404
+		[Token(Token = "0x4001904")]
+		TBStr,
+		/// <summary>A 2-byte, OLE-defined VARIANT_BOOL type (<see langword="true" /> = -1, <see langword="false" /> = 0).</summary>
+		// Token: 0x04001905 RID: 6405
+		[Token(Token = "0x4001905")]
+		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: 0x04001906 RID: 6406
+		[Token(Token = "0x4001906")]
+		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: 0x04001907 RID: 6407
+		[Token(Token = "0x4001907")]
+		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: 0x04001908 RID: 6408
+		[Token(Token = "0x4001908")]
+		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: 0x04001909 RID: 6409
+		[Token(Token = "0x4001909")]
+		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: 0x0400190A RID: 6410
+		[Token(Token = "0x400190A")]
+		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: 0x0400190B RID: 6411
+		[Token(Token = "0x400190B")]
+		Error,
+		/// <summary>A Windows Runtime interface pointer. You can use this member on the <see cref="T:System.Object" /> data type.</summary>
+		// Token: 0x0400190C RID: 6412
+		[Token(Token = "0x400190C")]
+		[ComVisible(false)]
+		IInspectable,
+		/// <summary>A Windows Runtime string. You can use this member on the <see cref="T:System.String" /> data type.</summary>
+		// Token: 0x0400190D RID: 6413
+		[Token(Token = "0x400190D")]
+		[ComVisible(false)]
+		HString,
+		/// <summary>A pointer to a UTF-8 encoded string.</summary>
+		// Token: 0x0400190E RID: 6414
+		[Token(Token = "0x400190E")]
+		[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: 0x0200056D RID: 1389
+	[Token(Token = "0x200056D")]
+	[ComVisible(true)]
+	[Serializable]
+	public enum VarEnum
+	{
+		/// <summary>Indicates that a value was not specified.</summary>
+		// Token: 0x040018BC RID: 6332
+		[Token(Token = "0x40018BC")]
+		VT_EMPTY,
+		/// <summary>Indicates a null value, similar to a null value in SQL.</summary>
+		// Token: 0x040018BD RID: 6333
+		[Token(Token = "0x40018BD")]
+		VT_NULL,
+		/// <summary>Indicates a <see langword="short" /> integer.</summary>
+		// Token: 0x040018BE RID: 6334
+		[Token(Token = "0x40018BE")]
+		VT_I2,
+		/// <summary>Indicates a <see langword="long" /> integer.</summary>
+		// Token: 0x040018BF RID: 6335
+		[Token(Token = "0x40018BF")]
+		VT_I4,
+		/// <summary>Indicates a <see langword="float" /> value.</summary>
+		// Token: 0x040018C0 RID: 6336
+		[Token(Token = "0x40018C0")]
+		VT_R4,
+		/// <summary>Indicates a <see langword="double" /> value.</summary>
+		// Token: 0x040018C1 RID: 6337
+		[Token(Token = "0x40018C1")]
+		VT_R8,
+		/// <summary>Indicates a currency value.</summary>
+		// Token: 0x040018C2 RID: 6338
+		[Token(Token = "0x40018C2")]
+		VT_CY,
+		/// <summary>Indicates a DATE value.</summary>
+		// Token: 0x040018C3 RID: 6339
+		[Token(Token = "0x40018C3")]
+		VT_DATE,
+		/// <summary>Indicates a BSTR string.</summary>
+		// Token: 0x040018C4 RID: 6340
+		[Token(Token = "0x40018C4")]
+		VT_BSTR,
+		/// <summary>Indicates an <see langword="IDispatch" /> pointer.</summary>
+		// Token: 0x040018C5 RID: 6341
+		[Token(Token = "0x40018C5")]
+		VT_DISPATCH,
+		/// <summary>Indicates an SCODE.</summary>
+		// Token: 0x040018C6 RID: 6342
+		[Token(Token = "0x40018C6")]
+		VT_ERROR,
+		/// <summary>Indicates a Boolean value.</summary>
+		// Token: 0x040018C7 RID: 6343
+		[Token(Token = "0x40018C7")]
+		VT_BOOL,
+		/// <summary>Indicates a VARIANT <see langword="far" /> pointer.</summary>
+		// Token: 0x040018C8 RID: 6344
+		[Token(Token = "0x40018C8")]
+		VT_VARIANT,
+		/// <summary>Indicates an <see langword="IUnknown" /> pointer.</summary>
+		// Token: 0x040018C9 RID: 6345
+		[Token(Token = "0x40018C9")]
+		VT_UNKNOWN,
+		/// <summary>Indicates a <see langword="decimal" /> value.</summary>
+		// Token: 0x040018CA RID: 6346
+		[Token(Token = "0x40018CA")]
+		VT_DECIMAL,
+		/// <summary>Indicates a <see langword="char" /> value.</summary>
+		// Token: 0x040018CB RID: 6347
+		[Token(Token = "0x40018CB")]
+		VT_I1 = 16,
+		/// <summary>Indicates a <see langword="byte" />.</summary>
+		// Token: 0x040018CC RID: 6348
+		[Token(Token = "0x40018CC")]
+		VT_UI1,
+		/// <summary>Indicates an <see langword="unsigned" /><see langword="short" />.</summary>
+		// Token: 0x040018CD RID: 6349
+		[Token(Token = "0x40018CD")]
+		VT_UI2,
+		/// <summary>Indicates an <see langword="unsigned" /><see langword="long" />.</summary>
+		// Token: 0x040018CE RID: 6350
+		[Token(Token = "0x40018CE")]
+		VT_UI4,
+		/// <summary>Indicates a 64-bit integer.</summary>
+		// Token: 0x040018CF RID: 6351
+		[Token(Token = "0x40018CF")]
+		VT_I8,
+		/// <summary>Indicates an 64-bit unsigned integer.</summary>
+		// Token: 0x040018D0 RID: 6352
+		[Token(Token = "0x40018D0")]
+		VT_UI8,
+		/// <summary>Indicates an integer value.</summary>
+		// Token: 0x040018D1 RID: 6353
+		[Token(Token = "0x40018D1")]
+		VT_INT,
+		/// <summary>Indicates an <see langword="unsigned" /> integer value.</summary>
+		// Token: 0x040018D2 RID: 6354
+		[Token(Token = "0x40018D2")]
+		VT_UINT,
+		/// <summary>Indicates a C style <see langword="void" />.</summary>
+		// Token: 0x040018D3 RID: 6355
+		[Token(Token = "0x40018D3")]
+		VT_VOID,
+		/// <summary>Indicates an HRESULT.</summary>
+		// Token: 0x040018D4 RID: 6356
+		[Token(Token = "0x40018D4")]
+		VT_HRESULT,
+		/// <summary>Indicates a pointer type.</summary>
+		// Token: 0x040018D5 RID: 6357
+		[Token(Token = "0x40018D5")]
+		VT_PTR,
+		/// <summary>Indicates a SAFEARRAY. Not valid in a VARIANT.</summary>
+		// Token: 0x040018D6 RID: 6358
+		[Token(Token = "0x40018D6")]
+		VT_SAFEARRAY,
+		/// <summary>Indicates a C style array.</summary>
+		// Token: 0x040018D7 RID: 6359
+		[Token(Token = "0x40018D7")]
+		VT_CARRAY,
+		/// <summary>Indicates a user defined type.</summary>
+		// Token: 0x040018D8 RID: 6360
+		[Token(Token = "0x40018D8")]
+		VT_USERDEFINED,
+		/// <summary>Indicates a null-terminated string.</summary>
+		// Token: 0x040018D9 RID: 6361
+		[Token(Token = "0x40018D9")]
+		VT_LPSTR,
+		/// <summary>Indicates a wide string terminated by <see langword="null" />.</summary>
+		// Token: 0x040018DA RID: 6362
+		[Token(Token = "0x40018DA")]
+		VT_LPWSTR,
+		/// <summary>Indicates a user defined type.</summary>
+		// Token: 0x040018DB RID: 6363
+		[Token(Token = "0x40018DB")]
+		VT_RECORD = 36,
+		/// <summary>Indicates a FILETIME value.</summary>
+		// Token: 0x040018DC RID: 6364
+		[Token(Token = "0x40018DC")]
+		VT_FILETIME = 64,
+		/// <summary>Indicates length prefixed bytes.</summary>
+		// Token: 0x040018DD RID: 6365
+		[Token(Token = "0x40018DD")]
+		VT_BLOB,
+		/// <summary>Indicates that the name of a stream follows.</summary>
+		// Token: 0x040018DE RID: 6366
+		[Token(Token = "0x40018DE")]
+		VT_STREAM,
+		/// <summary>Indicates that the name of a storage follows.</summary>
+		// Token: 0x040018DF RID: 6367
+		[Token(Token = "0x40018DF")]
+		VT_STORAGE,
+		/// <summary>Indicates that a stream contains an object.</summary>
+		// Token: 0x040018E0 RID: 6368
+		[Token(Token = "0x40018E0")]
+		VT_STREAMED_OBJECT,
+		/// <summary>Indicates that a storage contains an object.</summary>
+		// Token: 0x040018E1 RID: 6369
+		[Token(Token = "0x40018E1")]
+		VT_STORED_OBJECT,
+		/// <summary>Indicates that a blob contains an object.</summary>
+		// Token: 0x040018E2 RID: 6370
+		[Token(Token = "0x40018E2")]
+		VT_BLOB_OBJECT,
+		/// <summary>Indicates the clipboard format.</summary>
+		// Token: 0x040018E3 RID: 6371
+		[Token(Token = "0x40018E3")]
+		VT_CF,
+		/// <summary>Indicates a class ID.</summary>
+		// Token: 0x040018E4 RID: 6372
+		[Token(Token = "0x40018E4")]
+		VT_CLSID,
+		/// <summary>Indicates a simple, counted array.</summary>
+		// Token: 0x040018E5 RID: 6373
+		[Token(Token = "0x40018E5")]
+		VT_VECTOR = 4096,
+		/// <summary>Indicates a <see langword="SAFEARRAY" /> pointer.</summary>
+		// Token: 0x040018E6 RID: 6374
+		[Token(Token = "0x40018E6")]
+		VT_ARRAY = 8192,
+		/// <summary>Indicates that a value is a reference.</summary>
+		// Token: 0x040018E7 RID: 6375
+		[Token(Token = "0x40018E7")]
+		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: 0x0200058B RID: 1419
+	[Token(Token = "0x200058B")]
+	[Guid("03973551-57A1-3900-A2B5-9083E3FF2943")]
+	[CLSCompliant(false)]
+	[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: 0x0200058C RID: 1420
+	[Token(Token = "0x200058C")]
+	[Guid("17156360-2F1A-384A-BC52-FDE93C215C5B")]
+	[CLSCompliant(false)]
+	[InterfaceType(ComInterfaceType.InterfaceIsDual)]
+	[ComVisible(true)]
+	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: 0x0200058D RID: 1421
+	[Token(Token = "0x200058D")]
+	[CLSCompliant(false)]
+	[ComVisible(true)]
+	[Guid("B42B6AAC-317E-34D5-9FA9-093BB4160C50")]
+	[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+	public interface _AssemblyName
+	{
+	}
+}

mscorlib/System/Runtime/InteropServices/_ConstructorInfo.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.ConstructorInfo" /> class to unmanaged code.</summary>
+	// Token: 0x0200058E RID: 1422
+	[Token(Token = "0x200058E")]
+	[Guid("E9A19478-9646-3679-9B10-8411AE1FD57D")]
+	[CLSCompliant(false)]
+	[ComVisible(true)]
+	[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+	public interface _ConstructorInfo
+	{
+	}
+}

mscorlib/System/Runtime/InteropServices/_EventInfo.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.EventInfo" /> class to unmanaged code.</summary>
+	// Token: 0x0200058F RID: 1423
+	[Token(Token = "0x200058F")]
+	[CLSCompliant(false)]
+	[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+	[Guid("9DE59C64-D889-35A1-B897-587D74469E5B")]
+	[ComVisible(true)]
+	public interface _EventInfo
+	{
+	}
+}

mscorlib/System/Runtime/InteropServices/_Exception.cs

@@ -0,0 +1,16 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Exposes the public members of the <see cref="T:System.Exception" /> class to unmanaged code.</summary>
+	// Token: 0x02000590 RID: 1424
+	[Token(Token = "0x2000590")]
+	[ComVisible(true)]
+	[Guid("b36b5c63-42ef-38bc-a07e-0b34c98f164a")]
+	[CLSCompliant(false)]
+	[InterfaceType(ComInterfaceType.InterfaceIsDual)]
+	public interface _Exception
+	{
+	}
+}