scripts

mscorlib/System/Runtime/CompilerServices/AccessedThroughPropertyAttribute.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Specifies the name of the property that accesses the attributed field.</summary>
+	// Token: 0x0200028D RID: 653
+	[AttributeUsage(AttributeTargets.Field)]
+	[ComVisible(true)]
+	public sealed class AccessedThroughPropertyAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the AccessedThroughPropertyAttribute class with the name of the property used to access the attributed field.</summary>
+		/// <param name="propertyName">The name of the property used to access the attributed field. </param>
+		// Token: 0x060020DB RID: 8411 RVA: 0x00078B44 File Offset: 0x00076D44
+		public AccessedThroughPropertyAttribute(string propertyName)
+		{
+			this.name = propertyName;
+		}
+
+		/// <summary>Gets the name of the property used to access the attributed field.</summary>
+		/// <returns>The name of the property used to access the attributed field.</returns>
+		// Token: 0x17000629 RID: 1577
+		// (get) Token: 0x060020DC RID: 8412 RVA: 0x00078B54 File Offset: 0x00076D54
+		public string PropertyName
+		{
+			get
+			{
+				return this.name;
+			}
+		}
+
+		// Token: 0x04000BC1 RID: 3009
+		private string name;
+	}
+}

mscorlib/System/Runtime/CompilerServices/CallConvCdecl.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Indicates that a method should use the Cdecl calling convention.</summary>
+	// Token: 0x0200028E RID: 654
+	[ComVisible(true)]
+	public class CallConvCdecl
+	{
+	}
+}

mscorlib/System/Runtime/CompilerServices/CallConvFastcall.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>This calling convention is not supported in this version of the .NET Framework.</summary>
+	// Token: 0x0200028F RID: 655
+	[ComVisible(true)]
+	public class CallConvFastcall
+	{
+	}
+}

mscorlib/System/Runtime/CompilerServices/CallConvStdcall.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Indicates that a method should use the StdCall calling convention.</summary>
+	// Token: 0x02000290 RID: 656
+	[ComVisible(true)]
+	public class CallConvStdcall
+	{
+	}
+}

mscorlib/System/Runtime/CompilerServices/CallConvThiscall.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Indicates that a method should use the ThisCall calling convention.</summary>
+	// Token: 0x02000291 RID: 657
+	[ComVisible(true)]
+	public class CallConvThiscall
+	{
+	}
+}

mscorlib/System/Runtime/CompilerServices/CompilationRelaxations.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Runtime.InteropServices;
+
+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: 0x02000292 RID: 658
+	[Flags]
+	[ComVisible(true)]
+	[Serializable]
+	public enum CompilationRelaxations
+	{
+		/// <summary>Marks an assembly as not requiring string-literal interning.</summary>
+		// Token: 0x04000BC3 RID: 3011
+		NoStringInterning = 8
+	}
+}

mscorlib/System/Runtime/CompilerServices/CompilationRelaxationsAttribute.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Runtime.InteropServices;
+
+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: 0x02000293 RID: 659
+	[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: 0x060020E1 RID: 8417 RVA: 0x00078B7C File Offset: 0x00076D7C
+		public CompilationRelaxationsAttribute(int relaxations)
+		{
+			this.relax = 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: 0x060020E2 RID: 8418 RVA: 0x00078B8C File Offset: 0x00076D8C
+		public CompilationRelaxationsAttribute(CompilationRelaxations relaxations)
+		{
+			this.relax = (int)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: 0x1700062A RID: 1578
+		// (get) Token: 0x060020E3 RID: 8419 RVA: 0x00078B9C File Offset: 0x00076D9C
+		public int CompilationRelaxations
+		{
+			get
+			{
+				return this.relax;
+			}
+		}
+
+		// Token: 0x04000BC4 RID: 3012
+		private int relax;
+	}
+}

mscorlib/System/Runtime/CompilerServices/CompilerGeneratedAttribute.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Distinguishes a compiler-generated element from a user-generated element. This class cannot be inherited.</summary>
+	// Token: 0x02000051 RID: 81
+	[AttributeUsage(AttributeTargets.All)]
+	[Serializable]
+	public sealed class CompilerGeneratedAttribute : Attribute
+	{
+	}
+}

mscorlib/System/Runtime/CompilerServices/CompilerGlobalScopeAttribute.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Indicates that a class should be treated as if it has global scope.</summary>
+	// Token: 0x02000294 RID: 660
+	[ComVisible(true)]
+	[AttributeUsage(AttributeTargets.Class)]
+	[Serializable]
+	public class CompilerGlobalScopeAttribute : Attribute
+	{
+	}
+}

mscorlib/System/Runtime/CompilerServices/CompilerMarshalOverride.cs

@@ -0,0 +1,10 @@
+using System;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Indicates that the modified instance of a variable differs from its true type when marshaling. This class cannot be inherited.</summary>
+	// Token: 0x02000295 RID: 661
+	public static class CompilerMarshalOverride
+	{
+	}
+}

mscorlib/System/Runtime/CompilerServices/CustomConstantAttribute.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Defines a constant value that a compiler can persist for a field or method parameter.</summary>
+	// Token: 0x02000296 RID: 662
+	[ComVisible(true)]
+	[AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
+	[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: 0x1700062B RID: 1579
+		// (get) Token: 0x060020E6 RID: 8422
+		public abstract object Value { get; }
+	}
+}

mscorlib/System/Runtime/CompilerServices/DateTimeConstantAttribute.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Persists an 8-byte <see cref="T:System.DateTime" /> constant for a field or parameter.</summary>
+	// Token: 0x02000297 RID: 663
+	[ComVisible(true)]
+	[AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
+	[Serializable]
+	public sealed class DateTimeConstantAttribute : CustomConstantAttribute
+	{
+		/// <summary>Initializes a new instance of the DateTimeConstantAttribute class with the number of 100-nanosecond ticks that represent the date and time of this instance.</summary>
+		/// <param name="ticks">The number of 100-nanosecond ticks that represent the date and time of this instance. </param>
+		// Token: 0x060020E7 RID: 8423 RVA: 0x00078BB4 File Offset: 0x00076DB4
+		public DateTimeConstantAttribute(long ticks)
+		{
+			this.ticks = ticks;
+		}
+
+		// Token: 0x1700062C RID: 1580
+		// (get) Token: 0x060020E8 RID: 8424 RVA: 0x00078BC4 File Offset: 0x00076DC4
+		internal long Ticks
+		{
+			get
+			{
+				return this.ticks;
+			}
+		}
+
+		/// <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: 0x1700062D RID: 1581
+		// (get) Token: 0x060020E9 RID: 8425 RVA: 0x00078BCC File Offset: 0x00076DCC
+		public override object Value
+		{
+			get
+			{
+				return this.ticks;
+			}
+		}
+
+		// Token: 0x04000BC5 RID: 3013
+		private long ticks;
+	}
+}

mscorlib/System/Runtime/CompilerServices/DecimalConstantAttribute.cs

@@ -0,0 +1,75 @@
+using System;
+using System.Runtime.InteropServices;
+
+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: 0x02000057 RID: 87
+	[ComVisible(true)]
+	[AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
+	[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: 0x06000687 RID: 1671 RVA: 0x00014CA0 File Offset: 0x00012EA0
+		[CLSCompliant(false)]
+		public DecimalConstantAttribute(byte scale, byte sign, uint hi, uint mid, uint low)
+		{
+			this.scale = scale;
+			this.sign = Convert.ToBoolean(sign);
+			this.hi = (int)hi;
+			this.mid = (int)mid;
+			this.low = (int)low;
+		}
+
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.CompilerServices.DecimalConstantAttribute" /> class with the specified signed 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>
+		// Token: 0x06000688 RID: 1672 RVA: 0x00014CE0 File Offset: 0x00012EE0
+		public DecimalConstantAttribute(byte scale, byte sign, int hi, int mid, int low)
+		{
+			this.scale = scale;
+			this.sign = Convert.ToBoolean(sign);
+			this.hi = hi;
+			this.mid = mid;
+			this.low = low;
+		}
+
+		/// <summary>Gets the decimal constant stored in this attribute.</summary>
+		/// <returns>The decimal constant stored in this attribute.</returns>
+		// Token: 0x170000C1 RID: 193
+		// (get) Token: 0x06000689 RID: 1673 RVA: 0x00014D20 File Offset: 0x00012F20
+		public decimal Value
+		{
+			get
+			{
+				return new decimal(this.low, this.mid, this.hi, this.sign, this.scale);
+			}
+		}
+
+		// Token: 0x040000A9 RID: 169
+		private byte scale;
+
+		// Token: 0x040000AA RID: 170
+		private bool sign;
+
+		// Token: 0x040000AB RID: 171
+		private int hi;
+
+		// Token: 0x040000AC RID: 172
+		private int mid;
+
+		// Token: 0x040000AD RID: 173
+		private int low;
+	}
+}

mscorlib/System/Runtime/CompilerServices/DefaultDependencyAttribute.cs

@@ -0,0 +1,34 @@
+using System;
+
+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: 0x02000298 RID: 664
+	[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: 0x060020EA RID: 8426 RVA: 0x00078BDC File Offset: 0x00076DDC
+		public DefaultDependencyAttribute(LoadHint loadHintArgument)
+		{
+			this.hint = loadHintArgument;
+		}
+
+		/// <summary>Gets the <see cref="T:System.Runtime.CompilerServices.LoadHint" /> value that indicates when an assembly loads a dependency.</summary>
+		/// <returns>One of the <see cref="T:System.Runtime.CompilerServices.LoadHint" /> values.</returns>
+		// Token: 0x1700062E RID: 1582
+		// (get) Token: 0x060020EB RID: 8427 RVA: 0x00078BEC File Offset: 0x00076DEC
+		public LoadHint LoadHint
+		{
+			get
+			{
+				return this.hint;
+			}
+		}
+
+		// Token: 0x04000BC6 RID: 3014
+		private LoadHint hint;
+	}
+}

mscorlib/System/Runtime/CompilerServices/DependencyAttribute.cs

@@ -0,0 +1,51 @@
+using System;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Indicates when a dependency is to be loaded by the referring assembly. This class cannot be inherited. </summary>
+	// Token: 0x02000299 RID: 665
+	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
+	[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: 0x060020EC RID: 8428 RVA: 0x00078BF4 File Offset: 0x00076DF4
+		public DependencyAttribute(string dependentAssemblyArgument, LoadHint loadHintArgument)
+		{
+			this.dependentAssembly = dependentAssemblyArgument;
+			this.hint = loadHintArgument;
+		}
+
+		/// <summary>Gets the value of the dependent assembly. </summary>
+		/// <returns>The name of the dependent assembly.</returns>
+		// Token: 0x1700062F RID: 1583
+		// (get) Token: 0x060020ED RID: 8429 RVA: 0x00078C0C File Offset: 0x00076E0C
+		public string DependentAssembly
+		{
+			get
+			{
+				return this.dependentAssembly;
+			}
+		}
+
+		/// <summary>Gets the <see cref="T:System.Runtime.CompilerServices.LoadHint" /> value that indicates when an assembly is to load a dependency. </summary>
+		/// <returns>One of the <see cref="T:System.Runtime.CompilerServices.LoadHint" /> values.</returns>
+		// Token: 0x17000630 RID: 1584
+		// (get) Token: 0x060020EE RID: 8430 RVA: 0x00078C14 File Offset: 0x00076E14
+		public LoadHint LoadHint
+		{
+			get
+			{
+				return this.hint;
+			}
+		}
+
+		// Token: 0x04000BC7 RID: 3015
+		private string dependentAssembly;
+
+		// Token: 0x04000BC8 RID: 3016
+		private LoadHint hint;
+	}
+}

mscorlib/System/Runtime/CompilerServices/DiscardableAttribute.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Marks a type definition as discardable.</summary>
+	// Token: 0x0200029A RID: 666
+	[ComVisible(true)]
+	public class DiscardableAttribute : Attribute
+	{
+	}
+}

mscorlib/System/Runtime/CompilerServices/FixedAddressValueTypeAttribute.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Fixes the address of a static value type field throughout its lifetime. This class cannot be inherited.</summary>
+	// Token: 0x0200029B RID: 667
+	[AttributeUsage(AttributeTargets.Field)]
+	[Serializable]
+	public sealed class FixedAddressValueTypeAttribute : Attribute
+	{
+	}
+}

mscorlib/System/Runtime/CompilerServices/FixedBufferAttribute.cs

@@ -0,0 +1,50 @@
+using System;
+
+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: 0x02000050 RID: 80
+	[AttributeUsage(AttributeTargets.Field, Inherited = false)]
+	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: 0x06000678 RID: 1656 RVA: 0x00014BF8 File Offset: 0x00012DF8
+		public FixedBufferAttribute(Type elementType, int length)
+		{
+			this.elementType = elementType;
+			this.length = length;
+		}
+
+		/// <summary>Gets the type of the elements contained in the fixed buffer. </summary>
+		/// <returns>The type of the elements.</returns>
+		// Token: 0x170000BB RID: 187
+		// (get) Token: 0x06000679 RID: 1657 RVA: 0x00014C10 File Offset: 0x00012E10
+		public Type ElementType
+		{
+			get
+			{
+				return this.elementType;
+			}
+		}
+
+		/// <summary>Gets the number of elements in the fixed buffer. </summary>
+		/// <returns>The number of elements in the fixed buffer.</returns>
+		// Token: 0x170000BC RID: 188
+		// (get) Token: 0x0600067A RID: 1658 RVA: 0x00014C18 File Offset: 0x00012E18
+		public int Length
+		{
+			get
+			{
+				return this.length;
+			}
+		}
+
+		// Token: 0x040000A3 RID: 163
+		private Type elementType;
+
+		// Token: 0x040000A4 RID: 164
+		private int length;
+	}
+}

mscorlib/System/Runtime/CompilerServices/HasCopySemanticsAttribute.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>This class is not used in the .NET Framework version 2.0 and is reserved for future use. This class cannot be inherited.</summary>
+	// Token: 0x0200029C RID: 668
+	[AttributeUsage(AttributeTargets.Struct)]
+	[Serializable]
+	public sealed class HasCopySemanticsAttribute : Attribute
+	{
+	}
+}

mscorlib/System/Runtime/CompilerServices/IDispatchConstantAttribute.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Indicates that the default value for the attributed field or parameter is an instance of <see cref="T:System.Runtime.InteropServices.DispatchWrapper" />, where the <see cref="P:System.Runtime.InteropServices.DispatchWrapper.WrappedObject" /> is null.</summary>
+	// Token: 0x0200029D RID: 669
+	[AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
+	[ComVisible(true)]
+	[Serializable]
+	public sealed class IDispatchConstantAttribute : CustomConstantAttribute
+	{
+		/// <summary>Gets the IDispatch constant stored in this attribute.</summary>
+		/// <returns>The IDispatch constant stored in this attribute. Only null is allowed for an IDispatch constant value.</returns>
+		/// <PermissionSet>
+		///   <IPermission class="System.Security.Permissions.SecurityPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="UnmanagedCode" />
+		/// </PermissionSet>
+		// Token: 0x17000631 RID: 1585
+		// (get) Token: 0x060020F3 RID: 8435 RVA: 0x00078C3C File Offset: 0x00076E3C
+		public override object Value
+		{
+			get
+			{
+				return null;
+			}
+		}
+	}
+}

mscorlib/System/Runtime/CompilerServices/IUnknownConstantAttribute.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Indicates that the default value for the attributed field or parameter is an instance of <see cref="T:System.Runtime.InteropServices.UnknownWrapper" />, where the <see cref="P:System.Runtime.InteropServices.UnknownWrapper.WrappedObject" /> is null. This class cannot be inherited. </summary>
+	// Token: 0x0200029E RID: 670
+	[AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
+	[ComVisible(true)]
+	[Serializable]
+	public sealed class IUnknownConstantAttribute : CustomConstantAttribute
+	{
+		/// <summary>Gets the IUnknown constant stored in this attribute.</summary>
+		/// <returns>The IUnknown constant stored in this attribute. Only null is allowed for an IUnknown constant value.</returns>
+		// Token: 0x17000632 RID: 1586
+		// (get) Token: 0x060020F5 RID: 8437 RVA: 0x00078C48 File Offset: 0x00076E48
+		public override object Value
+		{
+			get
+			{
+				return null;
+			}
+		}
+	}
+}

mscorlib/System/Runtime/CompilerServices/IndexerNameAttribute.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Indicates the name by which an indexer is known in programming languages that do not support indexers directly.</summary>
+	// Token: 0x02000044 RID: 68
+	[AttributeUsage(AttributeTargets.Property, Inherited = true)]
+	[ComVisible(true)]
+	[Serializable]
+	public sealed class IndexerNameAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.CompilerServices.IndexerNameAttribute" /> class.</summary>
+		/// <param name="indexerName">The name of the indexer, as shown to other languages. </param>
+		// Token: 0x0600065F RID: 1631 RVA: 0x00014AF0 File Offset: 0x00012CF0
+		public IndexerNameAttribute(string indexerName)
+		{
+		}
+	}
+}

mscorlib/System/Runtime/CompilerServices/InternalsVisibleToAttribute.cs

@@ -0,0 +1,53 @@
+using System;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Specifies that types that are ordinarily visible only within the current assembly are visible to another assembly.</summary>
+	// Token: 0x02000052 RID: 82
+	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true, Inherited = false)]
+	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: 0x0600067C RID: 1660 RVA: 0x00014C28 File Offset: 0x00012E28
+		public InternalsVisibleToAttribute(string assemblyName)
+		{
+			this.assemblyName = assemblyName;
+		}
+
+		/// <summary>Gets the name of the friend assembly to which all types and type members that are marked with the internal keyword are to be made visible. </summary>
+		/// <returns>A string that represents the name of the friend assembly.</returns>
+		// Token: 0x170000BD RID: 189
+		// (get) Token: 0x0600067D RID: 1661 RVA: 0x00014C40 File Offset: 0x00012E40
+		public string AssemblyName
+		{
+			get
+			{
+				return this.assemblyName;
+			}
+		}
+
+		/// <summary>This property is not implemented.</summary>
+		/// <returns>This property does not return a value.</returns>
+		// Token: 0x170000BE RID: 190
+		// (get) Token: 0x0600067E RID: 1662 RVA: 0x00014C48 File Offset: 0x00012E48
+		// (set) Token: 0x0600067F RID: 1663 RVA: 0x00014C50 File Offset: 0x00012E50
+		public bool AllInternalsVisible
+		{
+			get
+			{
+				return this.all_visible;
+			}
+			set
+			{
+				this.all_visible = value;
+			}
+		}
+
+		// Token: 0x040000A5 RID: 165
+		private string assemblyName;
+
+		// Token: 0x040000A6 RID: 166
+		private bool all_visible = true;
+	}
+}

mscorlib/System/Runtime/CompilerServices/IsBoxed.cs

@@ -0,0 +1,10 @@
+using System;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Indicates that the modified reference type is a boxed value type. This class cannot be inherited.</summary>
+	// Token: 0x0200029F RID: 671
+	public static class IsBoxed
+	{
+	}
+}

mscorlib/System/Runtime/CompilerServices/IsByValue.cs

@@ -0,0 +1,10 @@
+using System;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Indicates that a modified method argument should be interpreted as having object passed-by-value semantics. This modifier is applied to reference types.  This class cannot be inherited.</summary>
+	// Token: 0x020002A0 RID: 672
+	public static class IsByValue
+	{
+	}
+}

mscorlib/System/Runtime/CompilerServices/IsConst.cs

@@ -0,0 +1,10 @@
+using System;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Indicates that the modified type has a const modifier. This class cannot be inherited.</summary>
+	// Token: 0x020002A1 RID: 673
+	public static class IsConst
+	{
+	}
+}

mscorlib/System/Runtime/CompilerServices/IsCopyConstructed.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Indicates that any copying of values of this type must use the copy constructor provided by the type.  This class cannot be inherited.</summary>
+	// Token: 0x020002A2 RID: 674
+	[ComVisible(true)]
+	public static class IsCopyConstructed
+	{
+	}
+}

mscorlib/System/Runtime/CompilerServices/IsExplicitlyDereferenced.cs

@@ -0,0 +1,10 @@
+using System;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Indicates that a managed pointer represents a pointer parameter within a method signature. This class cannot be inherited.</summary>
+	// Token: 0x020002A3 RID: 675
+	public static class IsExplicitlyDereferenced
+	{
+	}
+}

mscorlib/System/Runtime/CompilerServices/IsImplicitlyDereferenced.cs

@@ -0,0 +1,10 @@
+using System;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Indicates that the modified garbage collection reference represents a reference parameter within a method signature. This class cannot be inherited.</summary>
+	// Token: 0x020002A4 RID: 676
+	public static class IsImplicitlyDereferenced
+	{
+	}
+}

mscorlib/System/Runtime/CompilerServices/IsJitIntrinsic.cs

@@ -0,0 +1,10 @@
+using System;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Indicates that a modified method is an intrinsic value for which the just-in-time (JIT) compiler  can perform special code generation. This class cannot be inherited.</summary>
+	// Token: 0x020002A5 RID: 677
+	public static class IsJitIntrinsic
+	{
+	}
+}

mscorlib/System/Runtime/CompilerServices/IsLong.cs

@@ -0,0 +1,10 @@
+using System;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Indicates that a modified integer is a standard C++ long value. This class cannot be inherited.</summary>
+	// Token: 0x020002A6 RID: 678
+	public static class IsLong
+	{
+	}
+}

mscorlib/System/Runtime/CompilerServices/IsPinned.cs

@@ -0,0 +1,10 @@
+using System;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Indicates that a modified instance is pinned in memory. This class cannot be inherited.</summary>
+	// Token: 0x020002A7 RID: 679
+	public static class IsPinned
+	{
+	}
+}

mscorlib/System/Runtime/CompilerServices/IsSignUnspecifiedByte.cs

@@ -0,0 +1,10 @@
+using System;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Indicates that a modifier is neither signed nor unsigned. This class cannot be inherited.</summary>
+	// Token: 0x020002A8 RID: 680
+	public static class IsSignUnspecifiedByte
+	{
+	}
+}

mscorlib/System/Runtime/CompilerServices/IsUdtReturn.cs

@@ -0,0 +1,10 @@
+using System;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Indicates that a return type is a user-defined type. This class cannot be inherited.</summary>
+	// Token: 0x020002A9 RID: 681
+	public static class IsUdtReturn
+	{
+	}
+}

mscorlib/System/Runtime/CompilerServices/IsVolatile.cs

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

mscorlib/System/Runtime/CompilerServices/LoadHint.cs

@@ -0,0 +1,20 @@
+using System;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Specifies the preferred default binding for a dependent assembly.</summary>
+	// Token: 0x020002AB RID: 683
+	[Serializable]
+	public enum LoadHint
+	{
+		/// <summary>No preference specified.</summary>
+		// Token: 0x04000BCA RID: 3018
+		Default,
+		/// <summary>The dependency is always loaded.</summary>
+		// Token: 0x04000BCB RID: 3019
+		Always,
+		/// <summary>The dependency is sometimes loaded.</summary>
+		// Token: 0x04000BCC RID: 3020
+		Sometimes
+	}
+}

mscorlib/System/Runtime/CompilerServices/MethodCodeType.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Defines how a method is implemented.</summary>
+	// Token: 0x020002AC RID: 684
+	[ComVisible(true)]
+	[Serializable]
+	public enum MethodCodeType
+	{
+		/// <summary>Specifies that the method implementation is in Microsoft intermediate language (MSIL).</summary>
+		// Token: 0x04000BCE RID: 3022
+		IL,
+		/// <summary>Specifies that the method is implemented in native code.</summary>
+		// Token: 0x04000BCF RID: 3023
+		Native,
+		/// <summary>Specifies that the method implementation is in optimized intermediate language (OPTIL).</summary>
+		// Token: 0x04000BD0 RID: 3024
+		OPTIL,
+		/// <summary>Specifies that the method implementation is provided by the runtime.</summary>
+		// Token: 0x04000BD1 RID: 3025
+		Runtime
+	}
+}

mscorlib/System/Runtime/CompilerServices/MethodImplAttribute.cs

@@ -0,0 +1,54 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Specifies the details of how a method is implemented. This class cannot be inherited. </summary>
+	// Token: 0x02000041 RID: 65
+	[AttributeUsage(AttributeTargets.Constructor | AttributeTargets.Method, Inherited = false)]
+	[ComVisible(true)]
+	[Serializable]
+	public sealed class MethodImplAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.CompilerServices.MethodImplAttribute" /> class.</summary>
+		// Token: 0x06000657 RID: 1623 RVA: 0x00014A90 File Offset: 0x00012C90
+		public MethodImplAttribute()
+		{
+		}
+
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.CompilerServices.MethodImplAttribute" /> class with the specified <see cref="T:System.Runtime.CompilerServices.MethodImplOptions" /> value.</summary>
+		/// <param name="value">A bitmask representing the desired <see cref="T:System.Runtime.CompilerServices.MethodImplOptions" /> value which specifies properties of the attributed method. </param>
+		// Token: 0x06000658 RID: 1624 RVA: 0x00014A98 File Offset: 0x00012C98
+		public MethodImplAttribute(short value)
+		{
+			this._val = (MethodImplOptions)value;
+		}
+
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.CompilerServices.MethodImplAttribute" /> class with the specified <see cref="T:System.Runtime.CompilerServices.MethodImplOptions" /> value.</summary>
+		/// <param name="methodImplOptions">An enumeration value specifying properties of the attributed method. </param>
+		// Token: 0x06000659 RID: 1625 RVA: 0x00014AA8 File Offset: 0x00012CA8
+		public MethodImplAttribute(MethodImplOptions methodImplOptions)
+		{
+			this._val = methodImplOptions;
+		}
+
+		/// <summary>Gets the <see cref="T:System.Runtime.CompilerServices.MethodImplOptions" /> value describing the attributed method.</summary>
+		/// <returns>The <see cref="T:System.Runtime.CompilerServices.MethodImplOptions" /> value describing the attributed method.</returns>
+		// Token: 0x170000AF RID: 175
+		// (get) Token: 0x0600065A RID: 1626 RVA: 0x00014AB8 File Offset: 0x00012CB8
+		public MethodImplOptions Value
+		{
+			get
+			{
+				return this._val;
+			}
+		}
+
+		// Token: 0x0400008E RID: 142
+		private MethodImplOptions _val;
+
+		/// <summary>A <see cref="T:System.Runtime.CompilerServices.MethodCodeType" /> value indicating what kind of implementation is provided for this method.</summary>
+		// Token: 0x0400008F RID: 143
+		public MethodCodeType MethodCodeType;
+	}
+}

mscorlib/System/Runtime/CompilerServices/MethodImplOptions.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Defines the details of how a method is implemented.</summary>
+	// Token: 0x020002AD RID: 685
+	[Flags]
+	[ComVisible(true)]
+	[Serializable]
+	public enum MethodImplOptions
+	{
+		/// <summary>Specifies that the method is implemented in unmanaged code.</summary>
+		// Token: 0x04000BD3 RID: 3027
+		Unmanaged = 4,
+		/// <summary>Specifies that the method is declared, but its implementation is provided elsewhere.</summary>
+		// Token: 0x04000BD4 RID: 3028
+		ForwardRef = 16,
+		/// <summary>Specifies an internal call. An internal call is a call to a method that is implemented within the common language runtime itself.</summary>
+		// Token: 0x04000BD5 RID: 3029
+		InternalCall = 4096,
+		/// <summary>Specifies that the method can be executed by only one thread at a time.  Static methods lock on the type, whereas instance methods lock on the instance. Only one thread can execute in any of the instance functions, and only one thread can execute in any of a class's static functions.</summary>
+		// Token: 0x04000BD6 RID: 3030
+		Synchronized = 32,
+		/// <summary>Specifies that the method cannot be inlined.</summary>
+		// Token: 0x04000BD7 RID: 3031
+		NoInlining = 8,
+		/// <summary>Specifies that the method signature is exported exactly as declared.</summary>
+		// Token: 0x04000BD8 RID: 3032
+		PreserveSig = 128,
+		/// <summary>Specifies that the method is not optimized by the just-in-time (JIT) compiler or by native code generation (see Ngen.exe) when debugging possible code generation problems.</summary>
+		// Token: 0x04000BD9 RID: 3033
+		NoOptimization = 64
+	}
+}

mscorlib/System/Runtime/CompilerServices/NativeCppClassAttribute.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Applies metadata to an assembly that indicates that a type is an unmanaged type.  This class cannot be inherited.</summary>
+	// Token: 0x020002AE RID: 686
+	[ComVisible(true)]
+	[AttributeUsage(AttributeTargets.Struct, Inherited = true)]
+	[Serializable]
+	public sealed class NativeCppClassAttribute : Attribute
+	{
+	}
+}

mscorlib/System/Runtime/CompilerServices/RequiredAttributeAttribute.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Specifies that an importing compiler must fully understand the semantics of a type definition, or refuse to use it.  This class cannot be inherited. </summary>
+	// Token: 0x02000047 RID: 71
+	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Interface, AllowMultiple = true, Inherited = false)]
+	[ComVisible(true)]
+	[Serializable]
+	public sealed class RequiredAttributeAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.CompilerServices.RequiredAttributeAttribute" /> class.</summary>
+		/// <param name="requiredContract">A type that an importing compiler must fully understand.This parameter is not supported in the .NET Framework version 2.0 and later. </param>
+		// Token: 0x06000668 RID: 1640 RVA: 0x00014B48 File Offset: 0x00012D48
+		public RequiredAttributeAttribute(Type requiredContract)
+		{
+		}
+
+		/// <summary>Gets a type that an importing compiler must fully understand.</summary>
+		/// <returns>A type that an importing compiler must fully understand. </returns>
+		// Token: 0x170000B4 RID: 180
+		// (get) Token: 0x06000669 RID: 1641 RVA: 0x00014B50 File Offset: 0x00012D50
+		public Type RequiredContract
+		{
+			get
+			{
+				throw new NotSupportedException();
+			}
+		}
+	}
+}

mscorlib/System/Runtime/CompilerServices/RuntimeCompatibilityAttribute.cs

@@ -0,0 +1,31 @@
+using System;
+
+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: 0x02000053 RID: 83
+	[AttributeUsage(AttributeTargets.Assembly, Inherited = false, AllowMultiple = false)]
+	[Serializable]
+	public sealed class RuntimeCompatibilityAttribute : Attribute
+	{
+		/// <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>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, false.</returns>
+		// Token: 0x170000BF RID: 191
+		// (get) Token: 0x06000681 RID: 1665 RVA: 0x00014C64 File Offset: 0x00012E64
+		// (set) Token: 0x06000682 RID: 1666 RVA: 0x00014C6C File Offset: 0x00012E6C
+		public bool WrapNonExceptionThrows
+		{
+			get
+			{
+				return this.wrap_non_exception_throws;
+			}
+			set
+			{
+				this.wrap_non_exception_throws = value;
+			}
+		}
+
+		// Token: 0x040000A7 RID: 167
+		private bool wrap_non_exception_throws;
+	}
+}

mscorlib/System/Runtime/CompilerServices/RuntimeHelpers.cs

@@ -0,0 +1,197 @@
+using System;
+using System.Runtime.ConstrainedExecution;
+
+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: 0x02000061 RID: 97
+	public static class RuntimeHelpers
+	{
+		// Token: 0x060006C0 RID: 1728
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void InitializeArray(Array array, IntPtr fldHandle);
+
+		/// <summary>Provides a fast way to initialize an array from data stored in a module.</summary>
+		/// <param name="array">The array to be initialized. </param>
+		/// <param name="fldHandle">A <see cref="T:System.RuntimeFieldHandle" /> specifying the location of the data used to initialize the array. </param>
+		// Token: 0x060006C1 RID: 1729 RVA: 0x00015294 File Offset: 0x00013494
+		public static void InitializeArray(Array array, RuntimeFieldHandle fldHandle)
+		{
+			if (array == null || fldHandle.Value == IntPtr.Zero)
+			{
+				throw new ArgumentNullException();
+			}
+			RuntimeHelpers.InitializeArray(array, fldHandle.Value);
+		}
+
+		/// <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: 0x170000CB RID: 203
+		// (get) Token: 0x060006C2 RID: 1730
+		public static extern int OffsetToStringData
+		{
+			[MethodImpl(MethodImplOptions.InternalCall)]
+			get;
+		}
+
+		/// <summary>Serves as a hash function for a particular type, suitable for use in hashing algorithms and data structures such as a hash table.</summary>
+		/// <returns>A hash code for the <see cref="T:System.Object" /> identified by the <paramref name="o" /> parameter.</returns>
+		/// <param name="o">An <see cref="T:System.Object" /> to retrieve the hash code for. </param>
+		// Token: 0x060006C3 RID: 1731 RVA: 0x000152C8 File Offset: 0x000134C8
+		public static int GetHashCode(object o)
+		{
+			return object.InternalGetHashCode(o);
+		}
+
+		/// <summary>Determines whether the specified <see cref="T:System.Object" /> instances are considered equal.</summary>
+		/// <returns>true if the <paramref name="o1" /> parameter is the same instance as the <paramref name="o2" /> parameter or if both are null or if o1.Equals(o2) returns true; otherwise, false.</returns>
+		/// <param name="o1">The first <see cref="T:System.Object" /> to compare. </param>
+		/// <param name="o2">The second <see cref="T:System.Object" /> to compare. </param>
+		// Token: 0x060006C4 RID: 1732 RVA: 0x000152D0 File Offset: 0x000134D0
+		public new static bool Equals(object o1, object o2)
+		{
+			if (o1 == o2)
+			{
+				return true;
+			}
+			if (o1 == null || o2 == null)
+			{
+				return false;
+			}
+			if (o1 is ValueType)
+			{
+				return ValueType.DefaultEquals(o1, o2);
+			}
+			return object.Equals(o1, o2);
+		}
+
+		/// <summary>Boxes a value type.</summary>
+		/// <returns>Returns a boxed copy of <paramref name="obj" /> if it is a value class; otherwise <paramref name="obj" /> itself is returned.</returns>
+		/// <param name="obj">The value type to be boxed. </param>
+		// Token: 0x060006C5 RID: 1733
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		public static extern object GetObjectValue(object obj);
+
+		// Token: 0x060006C6 RID: 1734
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		private static extern void RunClassConstructor(IntPtr type);
+
+		/// <summary>Runs a specified class constructor method.</summary>
+		/// <param name="type">A <see cref="T:System.RuntimeTypeHandle" /> specifying the class constructor method to run. </param>
+		/// <exception cref="T:System.TypeInitializationException">The class initializer threw an exception. </exception>
+		// Token: 0x060006C7 RID: 1735 RVA: 0x00015304 File Offset: 0x00013504
+		public static void RunClassConstructor(RuntimeTypeHandle type)
+		{
+			if (type.Value == IntPtr.Zero)
+			{
+				throw new ArgumentException("Handle is not initialized.", "type");
+			}
+			RuntimeHelpers.RunClassConstructor(type.Value);
+		}
+
+		/// <summary>Executes code using a <see cref="T:System.Delegate" /> while using another <see cref="T:System.Delegate" /> to execute additional code in case of an exception.</summary>
+		/// <param name="code">A <see cref="T:System.Delegate" /> to the code to try.</param>
+		/// <param name="backoutCode">A <see cref="T:System.Delegate" /> to the code to run if a exception occurs.</param>
+		/// <param name="userData">The data to pass to <paramref name="code" /> and <paramref name="backoutCode" />.</param>
+		// Token: 0x060006C8 RID: 1736 RVA: 0x00015344 File Offset: 0x00013544
+		[MonoTODO("Currently a no-op")]
+		public static void ExecuteCodeWithGuaranteedCleanup(RuntimeHelpers.TryCode code, RuntimeHelpers.CleanupCode backoutCode, object userData)
+		{
+		}
+
+		/// <summary>Designates a body of code as a constrained execution region (CER).</summary>
+		/// <PermissionSet>
+		///   <IPermission class="System.Security.Permissions.SecurityPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="UnmanagedCode" />
+		/// </PermissionSet>
+		// Token: 0x060006C9 RID: 1737 RVA: 0x00015348 File Offset: 0x00013548
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
+		[MonoTODO("Currently a no-op")]
+		public static void PrepareConstrainedRegions()
+		{
+		}
+
+		/// <summary>Designates a body of code as a constrained execution region (CER) without performing any probing.  </summary>
+		// Token: 0x060006CA RID: 1738 RVA: 0x0001534C File Offset: 0x0001354C
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
+		[MonoTODO("Currently a no-op")]
+		public static void PrepareConstrainedRegionsNoOP()
+		{
+		}
+
+		/// <summary>Probes for a certain amount of stack space to ensure that a stack overflow cannot happen within a subsequent block of code (assuming that your code uses only a finite and moderate amount of stack space). We recommend that you use a constrained execution region (CER) instead of this method. </summary>
+		// Token: 0x060006CB RID: 1739 RVA: 0x00015350 File Offset: 0x00013550
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
+		[MonoTODO("Currently a no-op")]
+		public static void ProbeForSufficientStack()
+		{
+		}
+
+		/// <summary>Indicates that the specified delegate be prepared for inclusion in a constrained execution region (CER).</summary>
+		/// <param name="d">The <see cref="T:System.Delegate" /> type to prepare.</param>
+		/// <PermissionSet>
+		///   <IPermission class="System.Security.Permissions.SecurityPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="UnmanagedCode" />
+		/// </PermissionSet>
+		// Token: 0x060006CC RID: 1740 RVA: 0x00015354 File Offset: 0x00013554
+		[MonoTODO("Currently a no-op")]
+		public static void PrepareDelegate(Delegate d)
+		{
+			if (d == null)
+			{
+				throw new ArgumentNullException("d");
+			}
+		}
+
+		/// <summary>Prepares a method for inclusion in a constrained execution region (CER).</summary>
+		/// <param name="method">A <see cref="T:System.RuntimeMethodHandle" /> to the method to prepare.</param>
+		/// <PermissionSet>
+		///   <IPermission class="System.Security.Permissions.SecurityPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="UnmanagedCode" />
+		/// </PermissionSet>
+		// Token: 0x060006CD RID: 1741 RVA: 0x00015368 File Offset: 0x00013568
+		[MonoTODO("Currently a no-op")]
+		public static void PrepareMethod(RuntimeMethodHandle method)
+		{
+		}
+
+		/// <summary>Prepares a method for inclusion in a constrained execution region (CER) with the specified instantiation.</summary>
+		/// <param name="method">A <see cref="T:System.RuntimeMethodHandle" /> to the method to prepare.</param>
+		/// <param name="instantiation">A <see cref="T:System.RuntimeTypeHandle" /> instantiation to pass.</param>
+		/// <PermissionSet>
+		///   <IPermission class="System.Security.Permissions.SecurityPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="UnmanagedCode" />
+		/// </PermissionSet>
+		// Token: 0x060006CE RID: 1742 RVA: 0x0001536C File Offset: 0x0001356C
+		[MonoTODO("Currently a no-op")]
+		public static void PrepareMethod(RuntimeMethodHandle method, RuntimeTypeHandle[] instantiation)
+		{
+		}
+
+		/// <summary>Runs a specified module constructor method.</summary>
+		/// <param name="module">A <see cref="T:System.ModuleHandle" /> object specifying the module constructor method to run.</param>
+		/// <exception cref="T:System.TypeInitializationException">The module constructor threw an exception.</exception>
+		// Token: 0x060006CF RID: 1743 RVA: 0x00015370 File Offset: 0x00013570
+		public static void RunModuleConstructor(ModuleHandle module)
+		{
+			if (module == ModuleHandle.EmptyHandle)
+			{
+				throw new ArgumentException("Handle is not initialized.", "module");
+			}
+			RuntimeHelpers.RunModuleConstructor(module.Value);
+		}
+
+		// Token: 0x060006D0 RID: 1744
+		[MethodImpl(MethodImplOptions.InternalCall)]
+		public static extern void RunModuleConstructor(IntPtr module);
+
+		/// <summary>Represents a delegate to code that should be run in a try block..</summary>
+		/// <param name="userData">Data to pass to the delegate.</param>
+		// Token: 0x02000062 RID: 98
+		// (Invoke) Token: 0x060006D2 RID: 1746
+		public delegate void TryCode(object userData);
+
+		/// <summary>Represents a method to run when an exception occurs.</summary>
+		/// <param name="userData">Data to pass to the delegate.</param>
+		/// <param name="exceptionThrown">true to express that an exception was thrown; otherwise, false.</param>
+		// Token: 0x02000063 RID: 99
+		// (Invoke) Token: 0x060006D6 RID: 1750
+		public delegate void CleanupCode(object userData, bool exceptionThrown);
+	}
+}

mscorlib/System/Runtime/CompilerServices/RuntimeWrappedException.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Runtime.Serialization;
+
+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: 0x020002AF RID: 687
+	[Serializable]
+	public sealed class RuntimeWrappedException : Exception
+	{
+		// Token: 0x060020F7 RID: 8439 RVA: 0x00078C54 File Offset: 0x00076E54
+		private RuntimeWrappedException()
+		{
+		}
+
+		/// <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: 0x17000633 RID: 1587
+		// (get) Token: 0x060020F8 RID: 8440 RVA: 0x00078C5C File Offset: 0x00076E5C
+		public object WrappedException
+		{
+			get
+			{
+				return this.wrapped_exception;
+			}
+		}
+
+		/// <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 null.</exception>
+		// Token: 0x060020F9 RID: 8441 RVA: 0x00078C64 File Offset: 0x00076E64
+		public override void GetObjectData(SerializationInfo info, StreamingContext context)
+		{
+			base.GetObjectData(info, context);
+			info.AddValue("WrappedException", this.wrapped_exception);
+		}
+
+		// Token: 0x04000BDA RID: 3034
+		private object wrapped_exception;
+	}
+}

mscorlib/System/Runtime/CompilerServices/ScopelessEnumAttribute.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Indicates that a native enumeration is not qualified by the enumeration type name. This class cannot be inherited.</summary>
+	// Token: 0x020002B0 RID: 688
+	[AttributeUsage(AttributeTargets.Enum)]
+	[Serializable]
+	public sealed class ScopelessEnumAttribute : Attribute
+	{
+	}
+}

mscorlib/System/Runtime/CompilerServices/SpecialNameAttribute.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Indicates that a type or member is treated in a special way by the runtime or tools.  This class cannot be inherited.</summary>
+	// Token: 0x020002B1 RID: 689
+	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event)]
+	public sealed class SpecialNameAttribute : Attribute
+	{
+	}
+}

mscorlib/System/Runtime/CompilerServices/StringFreezingAttribute.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Deprecated. Freezes a string literal when creating native images using the Native Image Generator (Ngen.exe). This class cannot be inherited.</summary>
+	// Token: 0x020002B2 RID: 690
+	[AttributeUsage(AttributeTargets.Assembly, Inherited = false)]
+	[Serializable]
+	public sealed class StringFreezingAttribute : Attribute
+	{
+	}
+}

mscorlib/System/Runtime/CompilerServices/SuppressIldasmAttribute.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Prevents the MSIL Disassembler (Ildasm.exe) from disassembling an assembly. This class cannot be inherited.</summary>
+	// Token: 0x020002B3 RID: 691
+	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module)]
+	public sealed class SuppressIldasmAttribute : Attribute
+	{
+	}
+}

mscorlib/System/Runtime/CompilerServices/TypeForwardedToAttribute.cs

@@ -0,0 +1,33 @@
+using System;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Specifies a destination <see cref="T:System.Type" /> in another assembly.  This class cannot be inherited. </summary>
+	// Token: 0x0200004F RID: 79
+	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true, Inherited = false)]
+	public sealed class TypeForwardedToAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.CompilerServices.TypeForwardedToAttribute" /> class specifying a destination <see cref="T:System.Type" />. </summary>
+		/// <param name="destination">The destination <see cref="T:System.Type" /> in another assembly.</param>
+		// Token: 0x06000676 RID: 1654 RVA: 0x00014BE0 File Offset: 0x00012DE0
+		public TypeForwardedToAttribute(Type destination)
+		{
+			this.destination = destination;
+		}
+
+		/// <summary>Gets the destination <see cref="T:System.Type" /> in another assembly.</summary>
+		/// <returns>The destination <see cref="T:System.Type" /> in another assembly.</returns>
+		// Token: 0x170000BA RID: 186
+		// (get) Token: 0x06000677 RID: 1655 RVA: 0x00014BF0 File Offset: 0x00012DF0
+		public Type Destination
+		{
+			get
+			{
+				return this.destination;
+			}
+		}
+
+		// Token: 0x040000A2 RID: 162
+		private Type destination;
+	}
+}

mscorlib/System/Runtime/CompilerServices/UnsafeValueTypeAttribute.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace System.Runtime.CompilerServices
+{
+	/// <summary>Specifies that a type contains an unmanaged array that might potentially overflow. This class cannot be inherited.</summary>
+	// Token: 0x02000055 RID: 85
+	[AttributeUsage(AttributeTargets.Struct)]
+	[Serializable]
+	public sealed class UnsafeValueTypeAttribute : Attribute
+	{
+	}
+}

mscorlib/System/Runtime/ConstrainedExecution/Cer.cs

@@ -0,0 +1,20 @@
+using System;
+
+namespace System.Runtime.ConstrainedExecution
+{
+	/// <summary>Specifies a method's behavior when called within a constrained execution region.</summary>
+	// Token: 0x020002B4 RID: 692
+	[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: 0x04000BDC RID: 3036
+		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: 0x04000BDD RID: 3037
+		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: 0x04000BDE RID: 3038
+		Success
+	}
+}

mscorlib/System/Runtime/ConstrainedExecution/Consistency.cs

@@ -0,0 +1,23 @@
+using System;
+
+namespace System.Runtime.ConstrainedExecution
+{
+	/// <summary>Specifies a reliability contract.</summary>
+	// Token: 0x020002B5 RID: 693
+	[Serializable]
+	public enum Consistency
+	{
+		/// <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: 0x04000BE0 RID: 3040
+		MayCorruptAppDomain = 1,
+		/// <summary>In the face of exceptional conditions, the method is guaranteed to limit state corruption to the current instance.</summary>
+		// Token: 0x04000BE1 RID: 3041
+		MayCorruptInstance,
+		/// <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: 0x04000BE2 RID: 3042
+		MayCorruptProcess = 0,
+		/// <summary>In the face of exceptional conditions, the method is guaranteed not to corrupt state. </summary>
+		// Token: 0x04000BE3 RID: 3043
+		WillNotCorruptState = 3
+	}
+}

mscorlib/System/Runtime/ConstrainedExecution/CriticalFinalizerObject.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace System.Runtime.ConstrainedExecution
+{
+	/// <summary>Ensures that all finalization code in derived classes is marked as critical.</summary>
+	// Token: 0x020002B6 RID: 694
+	[ComVisible(true)]
+	public abstract class CriticalFinalizerObject
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.ConstrainedExecution.CriticalFinalizerObject" /> class.</summary>
+		// Token: 0x060020FE RID: 8446 RVA: 0x00078CA0 File Offset: 0x00076EA0
+		[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: 0x060020FF RID: 8447 RVA: 0x00078CA8 File Offset: 0x00076EA8
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
+		~CriticalFinalizerObject()
+		{
+		}
+	}
+}

mscorlib/System/Runtime/ConstrainedExecution/PrePrepareMethodAttribute.cs

@@ -0,0 +1,11 @@
+using System;
+
+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: 0x020002B7 RID: 695
+	[AttributeUsage(AttributeTargets.Constructor | AttributeTargets.Method, Inherited = false)]
+	public sealed class PrePrepareMethodAttribute : Attribute
+	{
+	}
+}

mscorlib/System/Runtime/ConstrainedExecution/ReliabilityContractAttribute.cs

@@ -0,0 +1,50 @@
+using System;
+
+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: 0x020002B8 RID: 696
+	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Interface, Inherited = false)]
+	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: 0x06002101 RID: 8449 RVA: 0x00078CE8 File Offset: 0x00076EE8
+		public ReliabilityContractAttribute(Consistency consistencyGuarantee, Cer cer)
+		{
+			this.consistency = consistencyGuarantee;
+			this.cer = cer;
+		}
+
+		/// <summary>Gets the value that determines the behavior of a method, type, or assembly when called under a Constrained Execution Region (CER). </summary>
+		/// <returns>One of the <see cref="T:System.Runtime.ConstrainedExecution.Cer" /> values.</returns>
+		// Token: 0x17000634 RID: 1588
+		// (get) Token: 0x06002102 RID: 8450 RVA: 0x00078D00 File Offset: 0x00076F00
+		public Cer Cer
+		{
+			get
+			{
+				return this.cer;
+			}
+		}
+
+		/// <summary>Gets the value of the <see cref="T:System.Runtime.ConstrainedExecution.Consistency" /> reliability contract. </summary>
+		/// <returns>One of the <see cref="T:System.Runtime.ConstrainedExecution.Consistency" /> values.</returns>
+		// Token: 0x17000635 RID: 1589
+		// (get) Token: 0x06002103 RID: 8451 RVA: 0x00078D08 File Offset: 0x00076F08
+		public Consistency ConsistencyGuarantee
+		{
+			get
+			{
+				return this.consistency;
+			}
+		}
+
+		// Token: 0x04000BE4 RID: 3044
+		private Consistency consistency;
+
+		// Token: 0x04000BE5 RID: 3045
+		private Cer cer;
+	}
+}

mscorlib/System/Runtime/GCLatencyMode.cs

@@ -0,0 +1,20 @@
+using System;
+
+namespace System.Runtime
+{
+	/// <summary>Adjusts the time that the garbage collector intrudes in your application.   </summary>
+	// Token: 0x0200049E RID: 1182
+	[Serializable]
+	public enum GCLatencyMode
+	{
+		/// <summary>Disables garbage collection concurrency and reclaims objects in a batch call. This is the most intrusive mode.</summary>
+		// Token: 0x04001154 RID: 4436
+		Batch,
+		/// <summary>Enables garbage collection concurrency and reclaims objects while the application is running. This is the default mode for garbage collection on a workstation and is less intrusive. It balances responsiveness with throughput.</summary>
+		// Token: 0x04001155 RID: 4437
+		Interactive,
+		/// <summary>Enables garbage collection that is more conservative in reclaiming objects. Full Collections occur only if the system is under memory pressure while generation 0 and generation 1 collections might occur more frequently. This is the least intrusive mode.</summary>
+		// Token: 0x04001156 RID: 4438
+		LowLatency
+	}
+}

mscorlib/System/Runtime/GCSettings.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Runtime.ConstrainedExecution;
+
+namespace System.Runtime
+{
+	/// <summary>Specifies the garbage collection settings for the current process. </summary>
+	// Token: 0x0200049F RID: 1183
+	public static class GCSettings
+	{
+		/// <summary>Gets a value indicating whether server garbage collection is enabled.</summary>
+		/// <returns>true if server garbage collection is enabled; otherwise, false.</returns>
+		// Token: 0x170008B4 RID: 2228
+		// (get) Token: 0x06002CA2 RID: 11426 RVA: 0x00092D70 File Offset: 0x00090F70
+		[MonoTODO("Always returns false")]
+		public static bool IsServerGC
+		{
+			get
+			{
+				return false;
+			}
+		}
+
+		/// <summary>Gets or sets the current latency mode for garbage collection.</summary>
+		/// <returns>One of the <see cref="T:System.Runtime.GCLatencyMode" /> values. </returns>
+		/// <exception cref="T:System.ArgumentOutOfRangeException">
+		///   <see cref="T:System.Runtime.GCLatencyMode" /> is set to an invalid value.</exception>
+		// Token: 0x170008B5 RID: 2229
+		// (get) Token: 0x06002CA3 RID: 11427 RVA: 0x00092D74 File Offset: 0x00090F74
+		// (set) Token: 0x06002CA4 RID: 11428 RVA: 0x00092D78 File Offset: 0x00090F78
+		[MonoTODO("Always returns GCLatencyMode.Interactive and ignores set (.NET 2.0 SP1 member)")]
+		public static GCLatencyMode LatencyMode
+		{
+			[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
+			get
+			{
+				return GCLatencyMode.Interactive;
+			}
+			[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
+			set
+			{
+			}
+		}
+	}
+}

mscorlib/System/Runtime/Hosting/ActivationArguments.cs

@@ -0,0 +1,119 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace System.Runtime.Hosting
+{
+	/// <summary>Provides data for manifest-based activation of an application. This class cannot be inherited. </summary>
+	// Token: 0x020002B9 RID: 697
+	[ComVisible(true)]
+	[Serializable]
+	public sealed class ActivationArguments
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.Hosting.ActivationArguments" /> class with the specified activation context. </summary>
+		/// <param name="activationData">An <see cref="T:System.ActivationContext" /> object identifying the manifest-based activation application.</param>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="activationData" /> is null.</exception>
+		// Token: 0x06002104 RID: 8452 RVA: 0x00078D10 File Offset: 0x00076F10
+		public ActivationArguments(ActivationContext activationData)
+		{
+			if (activationData == null)
+			{
+				throw new ArgumentNullException("activationData");
+			}
+			this._context = activationData;
+			this._identity = activationData.Identity;
+		}
+
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.Hosting.ActivationArguments" /> class with the specified application identity.</summary>
+		/// <param name="applicationIdentity">An <see cref="T:System.ApplicationIdentity" />  object identifying the manifest-based activation application.</param>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="applicationIdentity" /> is null.</exception>
+		// Token: 0x06002105 RID: 8453 RVA: 0x00078D48 File Offset: 0x00076F48
+		public ActivationArguments(ApplicationIdentity applicationIdentity)
+		{
+			if (applicationIdentity == null)
+			{
+				throw new ArgumentNullException("applicationIdentity");
+			}
+			this._identity = applicationIdentity;
+		}
+
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.Hosting.ActivationArguments" /> class with the specified activation context and activation data.</summary>
+		/// <param name="activationContext">An <see cref="T:System.ActivationContext" /> object identifying the manifest-based activation application.</param>
+		/// <param name="activationData">An array of strings containing host-provided activation data.</param>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="activationContext" /> is null.</exception>
+		// Token: 0x06002106 RID: 8454 RVA: 0x00078D68 File Offset: 0x00076F68
+		public ActivationArguments(ActivationContext activationContext, string[] activationData)
+		{
+			if (activationContext == null)
+			{
+				throw new ArgumentNullException("activationContext");
+			}
+			this._context = activationContext;
+			this._identity = activationContext.Identity;
+			this._data = activationData;
+		}
+
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.Hosting.ActivationArguments" /> class with the specified application identity and activation data.</summary>
+		/// <param name="applicationIdentity">An <see cref="T:System.ApplicationIdentity" /> object identifying the manifest-based activation application.</param>
+		/// <param name="activationData">An array of strings containing host-provided activation data.</param>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="applicationIdentity" /> is null.</exception>
+		// Token: 0x06002107 RID: 8455 RVA: 0x00078D9C File Offset: 0x00076F9C
+		public ActivationArguments(ApplicationIdentity applicationIdentity, string[] activationData)
+		{
+			if (applicationIdentity == null)
+			{
+				throw new ArgumentNullException("applicationIdentity");
+			}
+			this._identity = applicationIdentity;
+			this._data = activationData;
+		}
+
+		/// <summary>Gets the activation context for manifest-based activation of an application.</summary>
+		/// <returns>An <see cref="T:System.ActivationContext" /> object identifying a manifest-based activation application.</returns>
+		// Token: 0x17000636 RID: 1590
+		// (get) Token: 0x06002108 RID: 8456 RVA: 0x00078DC4 File Offset: 0x00076FC4
+		public ActivationContext ActivationContext
+		{
+			get
+			{
+				return this._context;
+			}
+		}
+
+		/// <summary>Gets activation data from the host.</summary>
+		/// <returns>An array of strings containing host-provided activation data.</returns>
+		// Token: 0x17000637 RID: 1591
+		// (get) Token: 0x06002109 RID: 8457 RVA: 0x00078DCC File Offset: 0x00076FCC
+		public string[] ActivationData
+		{
+			get
+			{
+				return this._data;
+			}
+		}
+
+		/// <summary>Gets the application identity for a manifest-activated application.</summary>
+		/// <returns>An <see cref="T:System.ApplicationIdentity" /> object identifying an application for manifest-based activation.</returns>
+		// Token: 0x17000638 RID: 1592
+		// (get) Token: 0x0600210A RID: 8458 RVA: 0x00078DD4 File Offset: 0x00076FD4
+		public ApplicationIdentity ApplicationIdentity
+		{
+			get
+			{
+				return this._identity;
+			}
+		}
+
+		// Token: 0x04000BE6 RID: 3046
+		private ActivationContext _context;
+
+		// Token: 0x04000BE7 RID: 3047
+		private ApplicationIdentity _identity;
+
+		// Token: 0x04000BE8 RID: 3048
+		private string[] _data;
+	}
+}

mscorlib/System/Runtime/Hosting/ApplicationActivator.cs

@@ -0,0 +1,82 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Runtime.Remoting;
+using System.Security;
+using System.Security.Policy;
+
+namespace System.Runtime.Hosting
+{
+	/// <summary>Provides the base class for the activation of manifest-based assemblies. </summary>
+	// Token: 0x020002BA RID: 698
+	[MonoTODO("missing manifest support")]
+	[ComVisible(true)]
+	public class ApplicationActivator
+	{
+		/// <summary>Creates an instance of the application to be activated, using the specified activation context. </summary>
+		/// <returns>An <see cref="T:System.Runtime.Remoting.ObjectHandle" /> that is a wrapper for the return value of the application execution. The return value must be unwrapped to access the real object.  </returns>
+		/// <param name="activationContext">An <see cref="T:System.ActivationContext" /> that identifies the application to activate.</param>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="activationContext" /> is null. </exception>
+		// Token: 0x0600210C RID: 8460 RVA: 0x00078DE4 File Offset: 0x00076FE4
+		public virtual ObjectHandle CreateInstance(ActivationContext activationContext)
+		{
+			return this.CreateInstance(activationContext, null);
+		}
+
+		/// <summary>Creates an instance of the application to be activated, using the specified activation context  and custom activation data.  </summary>
+		/// <returns>An <see cref="T:System.Runtime.Remoting.ObjectHandle" /> that is a wrapper for the return value of the application execution. The return value must be unwrapped to access the real object.</returns>
+		/// <param name="activationContext">An <see cref="T:System.ActivationContext" /> that identifies the application to activate.</param>
+		/// <param name="activationCustomData">Custom activation data.</param>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="activationContext" /> is null. </exception>
+		// Token: 0x0600210D RID: 8461 RVA: 0x00078DF0 File Offset: 0x00076FF0
+		public virtual ObjectHandle CreateInstance(ActivationContext activationContext, string[] activationCustomData)
+		{
+			if (activationContext == null)
+			{
+				throw new ArgumentNullException("activationContext");
+			}
+			AppDomainSetup appDomainSetup = new AppDomainSetup(activationContext);
+			return ApplicationActivator.CreateInstanceHelper(appDomainSetup);
+		}
+
+		/// <summary>Creates an instance of an application using the specified <see cref="T:System.AppDomainSetup" />  object.</summary>
+		/// <returns>An <see cref="T:System.Runtime.Remoting.ObjectHandle" /> that is a wrapper for the return value of the application execution. The return value must be unwrapped to access the real object. </returns>
+		/// <param name="adSetup">An <see cref="T:System.AppDomainSetup" /> object whose <see cref="P:System.AppDomainSetup.ActivationArguments" /> property identifies the application to activate.</param>
+		/// <exception cref="T:System.ArgumentException">The <see cref="P:System.AppDomainSetup.ActivationArguments" /> property of <paramref name="adSetup " />is null. </exception>
+		/// <exception cref="T:System.Security.Policy.PolicyException">The application instance failed to execute because the policy settings on the current application domain do not provide permission for this application to run.</exception>
+		// Token: 0x0600210E RID: 8462 RVA: 0x00078E1C File Offset: 0x0007701C
+		protected static ObjectHandle CreateInstanceHelper(AppDomainSetup adSetup)
+		{
+			if (adSetup == null)
+			{
+				throw new ArgumentNullException("adSetup");
+			}
+			if (adSetup.ActivationArguments == null)
+			{
+				string text = Locale.GetText("{0} is missing it's {1} property");
+				throw new ArgumentException(string.Format(text, "AppDomainSetup", "ActivationArguments"), "adSetup");
+			}
+			HostSecurityManager hostSecurityManager;
+			if (AppDomain.CurrentDomain.DomainManager != null)
+			{
+				hostSecurityManager = AppDomain.CurrentDomain.DomainManager.HostSecurityManager;
+			}
+			else
+			{
+				hostSecurityManager = new HostSecurityManager();
+			}
+			Evidence evidence = new Evidence();
+			evidence.AddHost(adSetup.ActivationArguments);
+			TrustManagerContext trustManagerContext = new TrustManagerContext();
+			ApplicationTrust applicationTrust = hostSecurityManager.DetermineApplicationTrust(evidence, null, trustManagerContext);
+			if (!applicationTrust.IsApplicationTrustedToRun)
+			{
+				string text2 = Locale.GetText("Current policy doesn't allow execution of addin.");
+				throw new PolicyException(text2);
+			}
+			AppDomain appDomain = AppDomain.CreateDomain("friendlyName", null, adSetup);
+			return appDomain.CreateInstance("assemblyName", "typeName", null);
+		}
+	}
+}

mscorlib/System/Runtime/InteropServices/AllowReversePInvokeCallsAttribute.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Allows an unmanaged method to call a managed method.</summary>
+	// Token: 0x020002EC RID: 748
+	[AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
+	public sealed class AllowReversePInvokeCallsAttribute : Attribute
+	{
+	}
+}

mscorlib/System/Runtime/InteropServices/ArrayWithOffset.cs

@@ -0,0 +1,98 @@
+using System;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Encapsulates an array and an offset within the specified array.</summary>
+	// Token: 0x020002ED RID: 749
+	[ComVisible(true)]
+	[Serializable]
+	public struct ArrayWithOffset
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.InteropServices.ArrayWithOffset" /> structure.</summary>
+		/// <param name="array">A managed array. </param>
+		/// <param name="offset">The offset in bytes, of the element to be passed through platform invoke. </param>
+		// Token: 0x060021B4 RID: 8628 RVA: 0x00078F04 File Offset: 0x00077104
+		public ArrayWithOffset(object array, int offset)
+		{
+			this.array = array;
+			this.offset = offset;
+		}
+
+		/// <summary>Indicates whether the specified object matches the current <see cref="T:System.Runtime.InteropServices.ArrayWithOffset" /> object.</summary>
+		/// <returns>true if the object matches this <see cref="T:System.Runtime.InteropServices.ArrayWithOffset" />; otherwise, false.</returns>
+		/// <param name="obj">Object to compare with this instance. </param>
+		// Token: 0x060021B5 RID: 8629 RVA: 0x00078F14 File Offset: 0x00077114
+		public override bool Equals(object obj)
+		{
+			if (obj == null)
+			{
+				return false;
+			}
+			if (!(obj is ArrayWithOffset))
+			{
+				return false;
+			}
+			ArrayWithOffset arrayWithOffset = (ArrayWithOffset)obj;
+			return arrayWithOffset.array == this.array && arrayWithOffset.offset == this.offset;
+		}
+
+		/// <summary>Indicates whether the specified <see cref="T:System.Runtime.InteropServices.ArrayWithOffset" /> object matches the current instance.</summary>
+		/// <returns>true if the specified <see cref="T:System.Runtime.InteropServices.ArrayWithOffset" /> object matches the current instance; otherwise, false.</returns>
+		/// <param name="obj">An <see cref="T:System.Runtime.InteropServices.ArrayWithOffset" /> object to compare with this instance.</param>
+		// Token: 0x060021B6 RID: 8630 RVA: 0x00078F64 File Offset: 0x00077164
+		public bool Equals(ArrayWithOffset obj)
+		{
+			return obj.array == this.array && obj.offset == this.offset;
+		}
+
+		/// <summary>Returns a hash code for this value type.</summary>
+		/// <returns>The hash code for this instance.</returns>
+		// Token: 0x060021B7 RID: 8631 RVA: 0x00078F98 File Offset: 0x00077198
+		public override int GetHashCode()
+		{
+			return this.offset;
+		}
+
+		/// <summary>Returns the managed array referenced by this <see cref="T:System.Runtime.InteropServices.ArrayWithOffset" />.</summary>
+		/// <returns>The managed array this instance references.</returns>
+		// Token: 0x060021B8 RID: 8632 RVA: 0x00078FA0 File Offset: 0x000771A0
+		public object GetArray()
+		{
+			return this.array;
+		}
+
+		/// <summary>Returns the offset provided when this <see cref="T:System.Runtime.InteropServices.ArrayWithOffset" /> was constructed.</summary>
+		/// <returns>The offset for this instance.</returns>
+		// Token: 0x060021B9 RID: 8633 RVA: 0x00078FA8 File Offset: 0x000771A8
+		public int GetOffset()
+		{
+			return this.offset;
+		}
+
+		/// <summary>Determines whether two specified <see cref="T:System.Runtime.InteropServices.ArrayWithOffset" /> objects have the same value.</summary>
+		/// <returns>true if the value of <paramref name="a" /> is the same as the value of <paramref name="b" />; otherwise, false.</returns>
+		/// <param name="a">An <see cref="T:System.Runtime.InteropServices.ArrayWithOffset" /> object to compare with the <paramref name="b" /> parameter. </param>
+		/// <param name="b">An <see cref="T:System.Runtime.InteropServices.ArrayWithOffset" /> object to compare with the <paramref name="a" /> parameter.</param>
+		// Token: 0x060021BA RID: 8634 RVA: 0x00078FB0 File Offset: 0x000771B0
+		public static bool operator ==(ArrayWithOffset a, ArrayWithOffset b)
+		{
+			return a.Equals(b);
+		}
+
+		/// <summary>Determines whether two specified <see cref="T:System.Runtime.InteropServices.ArrayWithOffset" /> objects no not have the same value.</summary>
+		/// <returns>true if the value of <paramref name="a" /> is not the same as the value of <paramref name="b" />; otherwise, false.</returns>
+		/// <param name="a">An <see cref="T:System.Runtime.InteropServices.ArrayWithOffset" /> object to compare with the <paramref name="b" /> parameter. </param>
+		/// <param name="b">An <see cref="T:System.Runtime.InteropServices.ArrayWithOffset" /> object to compare with the <paramref name="a" /> parameter.</param>
+		// Token: 0x060021BB RID: 8635 RVA: 0x00078FBC File Offset: 0x000771BC
+		public static bool operator !=(ArrayWithOffset a, ArrayWithOffset b)
+		{
+			return !a.Equals(b);
+		}
+
+		// Token: 0x04000CB9 RID: 3257
+		private object array;
+
+		// Token: 0x04000CBA RID: 3258
+		private int offset;
+	}
+}

mscorlib/System/Runtime/InteropServices/AssemblyRegistrationFlags.cs

@@ -0,0 +1,18 @@
+using System;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Defines a set of flags used when registering assemblies.</summary>
+	// Token: 0x020002EE RID: 750
+	[ComVisible(true)]
+	[Flags]
+	public enum AssemblyRegistrationFlags
+	{
+		/// <summary>Indicates no special settings.</summary>
+		// Token: 0x04000CBC RID: 3260
+		None = 0,
+		/// <summary>Indicates that the code base key for the assembly should be set in the registry.</summary>
+		// Token: 0x04000CBD RID: 3261
+		SetCodeBase = 1
+	}
+}

mscorlib/System/Runtime/InteropServices/AutomationProxyAttribute.cs

@@ -0,0 +1,34 @@
+using System;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Specifies whether the type should be marshaled using the Automation marshaler or a custom proxy and stub.</summary>
+	// Token: 0x020002EF RID: 751
+	[ComVisible(true)]
+	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Interface, Inherited = false)]
+	public sealed class AutomationProxyAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.InteropServices.AutomationProxyAttribute" /> class.</summary>
+		/// <param name="val">true if the class should be marshaled using the Automation Marshaler; false if a proxy stub marshaler should be used. </param>
+		// Token: 0x060021BC RID: 8636 RVA: 0x00078FCC File Offset: 0x000771CC
+		public AutomationProxyAttribute(bool val)
+		{
+			this.val = val;
+		}
+
+		/// <summary>Gets a value indicating the type of marshaler to use.</summary>
+		/// <returns>true if the class should be marshaled using the Automation Marshaler; false if a proxy stub marshaler should be used.</returns>
+		// Token: 0x17000639 RID: 1593
+		// (get) Token: 0x060021BD RID: 8637 RVA: 0x00078FDC File Offset: 0x000771DC
+		public bool Value
+		{
+			get
+			{
+				return this.val;
+			}
+		}
+
+		// Token: 0x04000CBE RID: 3262
+		private bool val;
+	}
+}

mscorlib/System/Runtime/InteropServices/BINDPTR.cs

@@ -0,0 +1,26 @@
+using System;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Use <see cref="T:System.Runtime.InteropServices.ComTypes.BINDPTR" /> instead.</summary>
+	// Token: 0x020002F0 RID: 752
+	[Obsolete]
+	[StructLayout(LayoutKind.Explicit, CharSet = CharSet.Unicode)]
+	public struct BINDPTR
+	{
+		/// <summary>Represents a pointer to a <see cref="T:System.Runtime.InteropServices.FUNCDESC" /> structure.</summary>
+		// Token: 0x04000CBF RID: 3263
+		[FieldOffset(0)]
+		public IntPtr lpfuncdesc;
+
+		/// <summary>Represents a pointer to a <see cref="F:System.Runtime.InteropServices.BINDPTR.lptcomp" /> interface.</summary>
+		// Token: 0x04000CC0 RID: 3264
+		[FieldOffset(0)]
+		public IntPtr lptcomp;
+
+		/// <summary>Represents a pointer to a <see cref="T:System.Runtime.InteropServices.VARDESC" /> structure.</summary>
+		// Token: 0x04000CC1 RID: 3265
+		[FieldOffset(0)]
+		public IntPtr lpvardesc;
+	}
+}

mscorlib/System/Runtime/InteropServices/BIND_OPTS.cs

@@ -0,0 +1,26 @@
+using System;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Use <see cref="T:System.Runtime.InteropServices.ComTypes.BIND_OPTS" /> instead.</summary>
+	// Token: 0x020002F1 RID: 753
+	[Obsolete]
+	public struct BIND_OPTS
+	{
+		/// <summary>Specifies the size of the BIND_OPTS structure in bytes.</summary>
+		// Token: 0x04000CC2 RID: 3266
+		public int cbStruct;
+
+		/// <summary>Controls aspects of moniker binding operations.</summary>
+		// Token: 0x04000CC3 RID: 3267
+		public int grfFlags;
+
+		/// <summary>Flags that should be used when opening the file that contains the object identified by the moniker.</summary>
+		// Token: 0x04000CC4 RID: 3268
+		public int grfMode;
+
+		/// <summary>Indicates the amount of time (clock time in milliseconds, as returned by the GetTickCount function) the caller specified to complete the binding operation.</summary>
+		// Token: 0x04000CC5 RID: 3269
+		public int dwTickCountDeadline;
+	}
+}

mscorlib/System/Runtime/InteropServices/BStrWrapper.cs

@@ -0,0 +1,34 @@
+using System;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Marshals data of type VT_BSTR from managed to unmanaged code. This class cannot be inherited.</summary>
+	// Token: 0x020002F2 RID: 754
+	[ComVisible(true)]
+	[Serializable]
+	public sealed class BStrWrapper
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.InteropServices.BStrWrapper" /> class with the specified <see cref="T:System.String" /> object.</summary>
+		/// <param name="value">The <see cref="T:System.String" /> object to wrap and marshal as VT_BSTR.</param>
+		// Token: 0x060021BE RID: 8638 RVA: 0x00078FE4 File Offset: 0x000771E4
+		public BStrWrapper(string value)
+		{
+			this._value = value;
+		}
+
+		/// <summary>Gets the wrapped <see cref="T:System.String" /> object to marshal as type VT_BSTR.</summary>
+		/// <returns>The <see cref="T:System.String" /> object wrapped by <see cref="T:System.Runtime.InteropServices.BStrWrapper" />.</returns>
+		// Token: 0x1700063A RID: 1594
+		// (get) Token: 0x060021BF RID: 8639 RVA: 0x00078FF4 File Offset: 0x000771F4
+		public string WrappedObject
+		{
+			get
+			{
+				return this._value;
+			}
+		}
+
+		// Token: 0x04000CC6 RID: 3270
+		private string _value;
+	}
+}

mscorlib/System/Runtime/InteropServices/BestFitMappingAttribute.cs

@@ -0,0 +1,38 @@
+using System;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Controls whether Unicode characters are converted to the closest matching ANSI characters.</summary>
+	// Token: 0x020002F3 RID: 755
+	[ComVisible(true)]
+	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface, Inherited = false)]
+	public sealed class BestFitMappingAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.InteropServices.BestFitMappingAttribute" /> class set to the value of the <see cref="P:System.Runtime.InteropServices.BestFitMappingAttribute.BestFitMapping" /> property.</summary>
+		/// <param name="BestFitMapping">true to indicate that best-fit mapping is enabled; otherwise, false. The default is true. </param>
+		// Token: 0x060021C0 RID: 8640 RVA: 0x00078FFC File Offset: 0x000771FC
+		public BestFitMappingAttribute(bool BestFitMapping)
+		{
+			this.bfm = BestFitMapping;
+		}
+
+		/// <summary>Gets the best-fit mapping behavior when converting Unicode characters to ANSI characters.</summary>
+		/// <returns>true if best-fit mapping is enabled; otherwise, false. The default is true.</returns>
+		// Token: 0x1700063B RID: 1595
+		// (get) Token: 0x060021C1 RID: 8641 RVA: 0x0007900C File Offset: 0x0007720C
+		public bool BestFitMapping
+		{
+			get
+			{
+				return this.bfm;
+			}
+		}
+
+		// Token: 0x04000CC7 RID: 3271
+		private bool bfm;
+
+		/// <summary>Enables or disables the throwing of an exception on an unmappable Unicode character that is converted to an ANSI '?' character.</summary>
+		// Token: 0x04000CC8 RID: 3272
+		public bool ThrowOnUnmappableChar;
+	}
+}

mscorlib/System/Runtime/InteropServices/CALLCONV.cs

@@ -0,0 +1,42 @@
+using System;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Use <see cref="T:System.Runtime.InteropServices.ComTypes.CALLCONV" /> instead.</summary>
+	// Token: 0x020002F4 RID: 756
+	[Obsolete]
+	[Serializable]
+	public enum CALLCONV
+	{
+		/// <summary>Indicates that the Cdecl calling convention is used for a method.</summary>
+		// Token: 0x04000CCA RID: 3274
+		CC_CDECL = 1,
+		/// <summary>Indicates that the Pascal calling convention is used for a method.</summary>
+		// Token: 0x04000CCB RID: 3275
+		CC_PASCAL,
+		/// <summary>Indicates that the Mscpascal calling convention is used for a method.</summary>
+		// Token: 0x04000CCC RID: 3276
+		CC_MSCPASCAL = 2,
+		/// <summary>Indicates that the Macpascal calling convention is used for a method.</summary>
+		// Token: 0x04000CCD RID: 3277
+		CC_MACPASCAL,
+		/// <summary>Indicates that the Stdcall calling convention is used for a method.</summary>
+		// Token: 0x04000CCE RID: 3278
+		CC_STDCALL,
+		/// <summary>This value is reserved for future use.</summary>
+		// Token: 0x04000CCF RID: 3279
+		CC_RESERVED,
+		/// <summary>Indicates that the Syscall calling convention is used for a method.</summary>
+		// Token: 0x04000CD0 RID: 3280
+		CC_SYSCALL,
+		/// <summary>Indicates that the Mpwcdecl calling convention is used for a method.</summary>
+		// Token: 0x04000CD1 RID: 3281
+		CC_MPWCDECL,
+		/// <summary>Indicates that the Mpwpascal calling convention is used for a method.</summary>
+		// Token: 0x04000CD2 RID: 3282
+		CC_MPWPASCAL,
+		/// <summary>Indicates the end of the <see cref="T:System.Runtime.InteropServices.CALLCONV" /> enumeration.</summary>
+		// Token: 0x04000CD3 RID: 3283
+		CC_MAX
+	}
+}

mscorlib/System/Runtime/InteropServices/COMException.cs

@@ -0,0 +1,74 @@
+using System;
+using System.Runtime.Serialization;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>The exception that is thrown when an unrecognized HRESULT is returned from a COM method call.</summary>
+	// Token: 0x020002F5 RID: 757
+	[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: 0x060021C2 RID: 8642 RVA: 0x00079014 File Offset: 0x00077214
+		public COMException()
+		{
+		}
+
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.InteropServices.COMException" /> class with a specified message.</summary>
+		/// <param name="message">The message that indicates the reason for the exception. </param>
+		// Token: 0x060021C3 RID: 8643 RVA: 0x0007901C File Offset: 0x0007721C
+		public COMException(string message)
+			: base(message)
+		{
+		}
+
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.InteropServices.COMException" /> 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 null, the current exception is raised in a catch block that handles the inner exception. </param>
+		// Token: 0x060021C4 RID: 8644 RVA: 0x00079028 File Offset: 0x00077228
+		public COMException(string message, Exception inner)
+			: base(message, inner)
+		{
+		}
+
+		/// <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: 0x060021C5 RID: 8645 RVA: 0x00079034 File Offset: 0x00077234
+		public COMException(string message, int errorCode)
+			: base(message, 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 null. </exception>
+		// Token: 0x060021C6 RID: 8646 RVA: 0x00079040 File Offset: 0x00077240
+		protected COMException(SerializationInfo info, StreamingContext context)
+			: base(info, 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>
+		/// <PermissionSet>
+		///   <IPermission class="System.Security.Permissions.FileIOPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" PathDiscovery="*AllFiles*" />
+		/// </PermissionSet>
+		// Token: 0x060021C7 RID: 8647 RVA: 0x0007904C File Offset: 0x0007724C
+		public override string ToString()
+		{
+			return string.Format("{0} (0x{1:x}): {2} {3}{4}{5}", new object[]
+			{
+				this.GetType(),
+				base.HResult,
+				this.Message,
+				(this.InnerException != null) ? this.InnerException.ToString() : string.Empty,
+				Environment.NewLine,
+				(this.StackTrace == null) ? string.Empty : this.StackTrace
+			});
+		}
+	}
+}

mscorlib/System/Runtime/InteropServices/CONNECTDATA.cs

@@ -0,0 +1,20 @@
+using System;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Use <see cref="T:System.Runtime.InteropServices.ComTypes.CONNECTDATA" /> instead.</summary>
+	// Token: 0x020002F6 RID: 758
+	[Obsolete]
+	[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+	public struct CONNECTDATA
+	{
+		/// <summary>Represents a pointer to the IUnknown interface on a connected advisory sink. The caller must call IUnknown::Release on this pointer when the CONNECTDATA structure is no longer needed.</summary>
+		// Token: 0x04000CD4 RID: 3284
+		[MarshalAs(UnmanagedType.Interface)]
+		public object pUnk;
+
+		/// <summary>Represents a connection token that is returned from a call to <see cref="M:System.Runtime.InteropServices.UCOMIConnectionPoint.Advise(System.Object,System.Int32@)" />.</summary>
+		// Token: 0x04000CD5 RID: 3285
+		public int dwCookie;
+	}
+}

mscorlib/System/Runtime/InteropServices/CallingConvention.cs

@@ -0,0 +1,27 @@
+using System;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Specifies the calling convention required to call methods implemented in unmanaged code.</summary>
+	// Token: 0x020002F7 RID: 759
+	[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: 0x04000CD7 RID: 3287
+		Winapi = 1,
+		/// <summary>The caller cleans the stack. This enables calling functions with varargs, which makes it appropriate to use for methods that accept a variable number of parameters, such as Printf.</summary>
+		// Token: 0x04000CD8 RID: 3288
+		Cdecl,
+		/// <summary>The callee cleans the stack. This is the default convention for calling unmanaged functions with platform invoke.</summary>
+		// Token: 0x04000CD9 RID: 3289
+		StdCall,
+		/// <summary>The first parameter is the 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: 0x04000CDA RID: 3290
+		ThisCall,
+		/// <summary>This calling convention is not supported.</summary>
+		// Token: 0x04000CDB RID: 3291
+		FastCall
+	}
+}

mscorlib/System/Runtime/InteropServices/CharSet.cs

@@ -0,0 +1,24 @@
+using System;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Dictates which character set marshaled strings should use.</summary>
+	// Token: 0x020002F8 RID: 760
+	[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: 0x04000CDD RID: 3293
+		None = 1,
+		/// <summary>Marshal strings as multiple-byte character strings.</summary>
+		// Token: 0x04000CDE RID: 3294
+		Ansi,
+		/// <summary>Marshal strings as Unicode 2-byte characters.</summary>
+		// Token: 0x04000CDF RID: 3295
+		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: 0x04000CE0 RID: 3296
+		Auto
+	}
+}

mscorlib/System/Runtime/InteropServices/ClassInterfaceAttribute.cs

@@ -0,0 +1,42 @@
+using System;
+
+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: 0x020002F9 RID: 761
+	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class, Inherited = false)]
+	[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 value.</summary>
+		/// <param name="classInterfaceType">Describes the type of interface that is generated for a class. </param>
+		// Token: 0x060021C8 RID: 8648 RVA: 0x000790D4 File Offset: 0x000772D4
+		public ClassInterfaceAttribute(short classInterfaceType)
+		{
+			this.ciType = (ClassInterfaceType)classInterfaceType;
+		}
+
+		/// <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: 0x060021C9 RID: 8649 RVA: 0x000790E4 File Offset: 0x000772E4
+		public ClassInterfaceAttribute(ClassInterfaceType classInterfaceType)
+		{
+			this.ciType = classInterfaceType;
+		}
+
+		/// <summary>Gets the <see cref="T:System.Runtime.InteropServices.ClassInterfaceType" /> value that describes which type of interface should be generated for the class.</summary>
+		/// <returns>The <see cref="T:System.Runtime.InteropServices.ClassInterfaceType" /> value that describes which type of interface should be generated for the class.</returns>
+		// Token: 0x1700063C RID: 1596
+		// (get) Token: 0x060021CA RID: 8650 RVA: 0x000790F4 File Offset: 0x000772F4
+		public ClassInterfaceType Value
+		{
+			get
+			{
+				return this.ciType;
+			}
+		}
+
+		// Token: 0x04000CE1 RID: 3297
+		private ClassInterfaceType ciType;
+	}
+}

mscorlib/System/Runtime/InteropServices/ClassInterfaceType.cs

@@ -0,0 +1,21 @@
+using System;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Identifies the type of class interface that is generated for a class.</summary>
+	// Token: 0x020002FA RID: 762
+	[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 IDispatch interface. This is the recommended setting for <see cref="T:System.Runtime.InteropServices.ClassInterfaceAttribute" />. Using ClassInterfaceType.None is the only way to expose functionality through interfaces implemented explicitly by the class.</summary>
+		// Token: 0x04000CE3 RID: 3299
+		None,
+		/// <summary>Indicates that the class only supports late binding for COM clients. A dispinterface for the class is automatically exposed to COM clients on request. The type library produced by Type Library Exporter (Tlbexp.exe) does not contain type information for the dispinterface in order to prevent clients from caching the DISPIDs of the interface. The 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: 0x04000CE4 RID: 3300
+		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 AutoDual is strongly discouraged because of the versioning limitations described in <see cref="T:System.Runtime.InteropServices.ClassInterfaceAttribute" />.</summary>
+		// Token: 0x04000CE5 RID: 3301
+		AutoDual
+	}
+}

mscorlib/System/Runtime/InteropServices/CoClassAttribute.cs

@@ -0,0 +1,34 @@
+using System;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Specifies the class identifier of a coclass imported from a type library.</summary>
+	// Token: 0x0200004C RID: 76
+	[ComVisible(true)]
+	[AttributeUsage(AttributeTargets.Interface, Inherited = false)]
+	public sealed class CoClassAttribute : Attribute
+	{
+		/// <summary>Initializes new instance of the <see cref="T:System.Runtime.InteropServices.CoClassAttribute" /> with the class identifier of the original coclass.</summary>
+		/// <param name="coClass">A <see cref="T:System.Type" /> that contains the class identifier of the original coclass. </param>
+		// Token: 0x06000671 RID: 1649 RVA: 0x00014BA8 File Offset: 0x00012DA8
+		public CoClassAttribute(Type coClass)
+		{
+			this.klass = coClass;
+		}
+
+		/// <summary>Gets the class identifier of the original coclass.</summary>
+		/// <returns>A <see cref="T:System.Type" /> containing the class identifier of the original coclass.</returns>
+		// Token: 0x170000B8 RID: 184
+		// (get) Token: 0x06000672 RID: 1650 RVA: 0x00014BB8 File Offset: 0x00012DB8
+		public Type CoClass
+		{
+			get
+			{
+				return this.klass;
+			}
+		}
+
+		// Token: 0x040000A0 RID: 160
+		private Type klass;
+	}
+}

mscorlib/System/Runtime/InteropServices/ComAliasNameAttribute.cs

@@ -0,0 +1,34 @@
+using System;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Indicates the COM alias for a parameter or field type.</summary>
+	// Token: 0x020002FB RID: 763
+	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
+	[ComVisible(true)]
+	public sealed class ComAliasNameAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.InteropServices.ComAliasNameAttribute" /> class with the alias for the attributed field or parameter.</summary>
+		/// <param name="alias">The alias for the field or parameter as found in the type library when it was imported. </param>
+		// Token: 0x060021CB RID: 8651 RVA: 0x000790FC File Offset: 0x000772FC
+		public ComAliasNameAttribute(string alias)
+		{
+			this.val = alias;
+		}
+
+		/// <summary>Gets the alias for the field or parameter as found in the type library when it was imported.</summary>
+		/// <returns>The alias for the field or parameter as found in the type library when it was imported.</returns>
+		// Token: 0x1700063D RID: 1597
+		// (get) Token: 0x060021CC RID: 8652 RVA: 0x0007910C File Offset: 0x0007730C
+		public string Value
+		{
+			get
+			{
+				return this.val;
+			}
+		}
+
+		// Token: 0x04000CE6 RID: 3302
+		private string val;
+	}
+}

mscorlib/System/Runtime/InteropServices/ComCompatibleVersionAttribute.cs

@@ -0,0 +1,85 @@
+using System;
+
+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: 0x020002FC RID: 764
+	[ComVisible(true)]
+	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = false, Inherited = false)]
+	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: 0x060021CD RID: 8653 RVA: 0x00079114 File Offset: 0x00077314
+		public ComCompatibleVersionAttribute(int major, int minor, int build, int revision)
+		{
+			this.major = major;
+			this.minor = minor;
+			this.build = build;
+			this.revision = revision;
+		}
+
+		/// <summary>Gets the major version number of the assembly.</summary>
+		/// <returns>The major version number of the assembly.</returns>
+		// Token: 0x1700063E RID: 1598
+		// (get) Token: 0x060021CE RID: 8654 RVA: 0x0007913C File Offset: 0x0007733C
+		public int MajorVersion
+		{
+			get
+			{
+				return this.major;
+			}
+		}
+
+		/// <summary>Gets the minor version number of the assembly.</summary>
+		/// <returns>The minor version number of the assembly.</returns>
+		// Token: 0x1700063F RID: 1599
+		// (get) Token: 0x060021CF RID: 8655 RVA: 0x00079144 File Offset: 0x00077344
+		public int MinorVersion
+		{
+			get
+			{
+				return this.minor;
+			}
+		}
+
+		/// <summary>Gets the build number of the assembly.</summary>
+		/// <returns>The build number of the assembly.</returns>
+		// Token: 0x17000640 RID: 1600
+		// (get) Token: 0x060021D0 RID: 8656 RVA: 0x0007914C File Offset: 0x0007734C
+		public int BuildNumber
+		{
+			get
+			{
+				return this.build;
+			}
+		}
+
+		/// <summary>Gets the revision number of the assembly.</summary>
+		/// <returns>The revision number of the assembly.</returns>
+		// Token: 0x17000641 RID: 1601
+		// (get) Token: 0x060021D1 RID: 8657 RVA: 0x00079154 File Offset: 0x00077354
+		public int RevisionNumber
+		{
+			get
+			{
+				return this.revision;
+			}
+		}
+
+		// Token: 0x04000CE7 RID: 3303
+		private int major;
+
+		// Token: 0x04000CE8 RID: 3304
+		private int minor;
+
+		// Token: 0x04000CE9 RID: 3305
+		private int build;
+
+		// Token: 0x04000CEA RID: 3306
+		private int revision;
+	}
+}

mscorlib/System/Runtime/InteropServices/ComConversionLossAttribute.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Indicates that information was lost about a class or interface when it was imported from a type library to an assembly.</summary>
+	// Token: 0x020002FD RID: 765
+	[ComVisible(true)]
+	[AttributeUsage(AttributeTargets.All, Inherited = false)]
+	public sealed class ComConversionLossAttribute : Attribute
+	{
+	}
+}

mscorlib/System/Runtime/InteropServices/ComDefaultInterfaceAttribute.cs

@@ -0,0 +1,34 @@
+using System;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Specifies a default interface to expose to COM. This class cannot be inherited.</summary>
+	// Token: 0x020002FE RID: 766
+	[AttributeUsage(AttributeTargets.Class, Inherited = false)]
+	[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: 0x060021D3 RID: 8659 RVA: 0x00079164 File Offset: 0x00077364
+		public ComDefaultInterfaceAttribute(Type defaultInterface)
+		{
+			this._type = defaultInterface;
+		}
+
+		/// <summary>Gets the <see cref="T:System.Type" /> object that specifies the default interface to expose to COM.</summary>
+		/// <returns>The <see cref="T:System.Type" /> object that specifies the default interface to expose to COM.</returns>
+		// Token: 0x17000642 RID: 1602
+		// (get) Token: 0x060021D4 RID: 8660 RVA: 0x00079174 File Offset: 0x00077374
+		public Type Value
+		{
+			get
+			{
+				return this._type;
+			}
+		}
+
+		// Token: 0x04000CEB RID: 3307
+		private Type _type;
+	}
+}

mscorlib/System/Runtime/InteropServices/ComEventInterfaceAttribute.cs

@@ -0,0 +1,51 @@
+using System;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Identifies the source interface and the class that implements the methods of the event interface that is generated when a coclass is imported from a COM type library.</summary>
+	// Token: 0x020002FF RID: 767
+	[AttributeUsage(AttributeTargets.Interface, Inherited = false)]
+	[ComVisible(true)]
+	public sealed class ComEventInterfaceAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.InteropServices.ComEventInterfaceAttribute" /> class with the source interface and event provider class.</summary>
+		/// <param name="SourceInterface">A <see cref="T:System.Type" /> that contains the original source interface from the type library. COM uses this interface to call back to the managed class. </param>
+		/// <param name="EventProvider">A <see cref="T:System.Type" /> that contains the class that implements the methods of the event interface. </param>
+		// Token: 0x060021D5 RID: 8661 RVA: 0x0007917C File Offset: 0x0007737C
+		public ComEventInterfaceAttribute(Type SourceInterface, Type EventProvider)
+		{
+			this.si = SourceInterface;
+			this.ep = EventProvider;
+		}
+
+		/// <summary>Gets the class that implements the methods of the event interface.</summary>
+		/// <returns>A <see cref="T:System.Type" /> that contains the class that implements the methods of the event interface.</returns>
+		// Token: 0x17000643 RID: 1603
+		// (get) Token: 0x060021D6 RID: 8662 RVA: 0x00079194 File Offset: 0x00077394
+		public Type EventProvider
+		{
+			get
+			{
+				return this.ep;
+			}
+		}
+
+		/// <summary>Gets the original source interface from the type library.</summary>
+		/// <returns>A <see cref="T:System.Type" /> containing the source interface.</returns>
+		// Token: 0x17000644 RID: 1604
+		// (get) Token: 0x060021D7 RID: 8663 RVA: 0x0007919C File Offset: 0x0007739C
+		public Type SourceInterface
+		{
+			get
+			{
+				return this.si;
+			}
+		}
+
+		// Token: 0x04000CEC RID: 3308
+		private Type si;
+
+		// Token: 0x04000CED RID: 3309
+		private Type ep;
+	}
+}

mscorlib/System/Runtime/InteropServices/ComImportAttribute.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Indicates that the attributed type was previously defined in COM.</summary>
+	// Token: 0x0200004B RID: 75
+	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, Inherited = false)]
+	[ComVisible(true)]
+	public sealed class ComImportAttribute : Attribute
+	{
+	}
+}

mscorlib/System/Runtime/InteropServices/ComInterfaceType.cs

@@ -0,0 +1,21 @@
+using System;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Identifies how to expose an interface to COM.</summary>
+	// Token: 0x02000300 RID: 768
+	[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: 0x04000CEF RID: 3311
+		InterfaceIsDual,
+		/// <summary>Indicates that an interface is exposed to COM as an IUnknown -derived interface, which enables only early binding.</summary>
+		// Token: 0x04000CF0 RID: 3312
+		InterfaceIsIUnknown,
+		/// <summary>Indicates that an interface is exposed to COM as a dispinterface, which enables late binding only.</summary>
+		// Token: 0x04000CF1 RID: 3313
+		InterfaceIsIDispatch
+	}
+}

mscorlib/System/Runtime/InteropServices/ComMemberType.cs

@@ -0,0 +1,21 @@
+using System;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Describes the type of a COM member.</summary>
+	// Token: 0x02000301 RID: 769
+	[ComVisible(true)]
+	[Serializable]
+	public enum ComMemberType
+	{
+		/// <summary>The member is a normal method.</summary>
+		// Token: 0x04000CF3 RID: 3315
+		Method,
+		/// <summary>The member gets properties.</summary>
+		// Token: 0x04000CF4 RID: 3316
+		PropGet,
+		/// <summary>The member sets properties.</summary>
+		// Token: 0x04000CF5 RID: 3317
+		PropSet
+	}
+}

mscorlib/System/Runtime/InteropServices/ComRegisterFunctionAttribute.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Specifies the method to call when you register an assembly for use from COM; this enables the execution of user-written code during the registration process.</summary>
+	// Token: 0x02000302 RID: 770
+	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
+	[ComVisible(true)]
+	public sealed class ComRegisterFunctionAttribute : Attribute
+	{
+	}
+}

mscorlib/System/Runtime/InteropServices/ComSourceInterfacesAttribute.cs

@@ -0,0 +1,72 @@
+using System;
+
+namespace System.Runtime.InteropServices
+{
+	/// <summary>Identifies a list of interfaces that are exposed as COM event sources for the attributed class.</summary>
+	// Token: 0x02000303 RID: 771
+	[ComVisible(true)]
+	[AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = true)]
+	public sealed class ComSourceInterfacesAttribute : Attribute
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.InteropServices.ComSourceInterfacesAttribute" /> class with the name of the event source interface.</summary>
+		/// <param name="sourceInterfaces">A null-delimited list of fully qualified event source interface names. </param>
+		// Token: 0x060021D9 RID: 8665 RVA: 0x000791AC File Offset: 0x000773AC
+		public ComSourceInterfacesAttribute(string sourceInterfaces)
+		{
+			this.internalValue = sourceInterfaces;
+		}
+
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.InteropServices.ComSourceInterfacesAttribute" /> class with the type to use as a source interface.</summary>
+		/// <param name="sourceInterface">The <see cref="T:System.Type" /> of the source interface. </param>
+		// Token: 0x060021DA RID: 8666 RVA: 0x000791BC File Offset: 0x000773BC
+		public ComSourceInterfacesAttribute(Type sourceInterface)
+		{
+			this.internalValue = sourceInterface.ToString();
+		}
+
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.InteropServices.ComSourceInterfacesAttribute" /> class with the types to use as source interfaces.</summary>
+		/// <param name="sourceInterface1">The <see cref="T:System.Type" /> of the default source interface. </param>
+		/// <param name="sourceInterface2">The <see cref="T:System.Type" /> of a source interface. </param>
+		// Token: 0x060021DB RID: 8667 RVA: 0x000791D0 File Offset: 0x000773D0
+		public ComSourceInterfacesAttribute(Type sourceInterface1, Type sourceInterface2)
+		{
+			this.internalValue = sourceInterface1.ToString() + sourceInterface2.ToString();
+		}
+
+		/// <summary>Initializes a new instance of the ComSourceInterfacesAttribute class with the types to use as source interfaces.</summary>
+		/// <param name="sourceInterface1">The <see cref="T:System.Type" /> of the default source interface. </param>
+		/// <param name="sourceInterface2">The <see cref="T:System.Type" /> of a source interface. </param>
+		/// <param name="sourceInterface3">The <see cref="T:System.Type" /> of a source interface. </param>
+		// Token: 0x060021DC RID: 8668 RVA: 0x000791FC File Offset: 0x000773FC
+		public ComSourceInterfacesAttribute(Type sourceInterface1, Type sourceInterface2, Type sourceInterface3)
+		{
+			this.internalValue = sourceInterface1.ToString() + sourceInterface2.ToString() + sourceInterface3.ToString();
+		}
+
+		/// <summary>Initializes a new instance of the <see cref="T:System.Runtime.InteropServices.ComSourceInterfacesAttribute" /> class with the types to use as source interfaces.</summary>
+		/// <param name="sourceInterface1">The <see cref="T:System.Type" /> of the default source interface. </param>
+		/// <param name="sourceInterface2">The <see cref="T:System.Type" /> of a source interface. </param>
+		/// <param name="sourceInterface3">The <see cref="T:System.Type" /> of a source interface. </param>
+		/// <param name="sourceInterface4">The <see cref="T:System.Type" /> of a source interface. </param>
+		// Token: 0x060021DD RID: 8669 RVA: 0x0007922C File Offset: 0x0007742C
+		public ComSourceInterfacesAttribute(Type sourceInterface1, Type sourceInterface2, Type sourceInterface3, Type sourceInterface4)
+		{
+			this.internalValue = sourceInterface1.ToString() + sourceInterface2.ToString() + sourceInterface3.ToString() + sourceInterface4.ToString();
+		}
+
+		/// <summary>Gets the fully qualified name of the event source interface.</summary>
+		/// <returns>The fully qualified name of the event source interface.</returns>
+		// Token: 0x17000645 RID: 1605
+		// (get) Token: 0x060021DE RID: 8670 RVA: 0x00079264 File Offset: 0x00077464
+		public string Value
+		{
+			get
+			{
+				return this.internalValue;
+			}
+		}
+
+		// Token: 0x04000CF6 RID: 3318
+		private string internalValue;
+	}
+}

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

@@ -0,0 +1,25 @@
+using System;
+
+namespace System.Runtime.InteropServices.ComTypes
+{
+	/// <summary>Contains a pointer to a bound-to <see cref="T:System.Runtime.InteropServices.FUNCDESC" /> structure, <see cref="T:System.Runtime.InteropServices.VARDESC" /> structure, or an ITypeComp interface.</summary>
+	// Token: 0x020002BB RID: 699
+	[StructLayout(LayoutKind.Explicit, CharSet = CharSet.Unicode)]
+	public struct BINDPTR
+	{
+		/// <summary>Represents a pointer to a <see cref="T:System.Runtime.InteropServices.FUNCDESC" /> structure.</summary>
+		// Token: 0x04000BE9 RID: 3049
+		[FieldOffset(0)]
+		public IntPtr lpfuncdesc;
+
+		/// <summary>Represents a pointer to an <see cref="T:System.Runtime.InteropServices.ComTypes.ITypeComp" /> interface.</summary>
+		// Token: 0x04000BEA RID: 3050
+		[FieldOffset(0)]
+		public IntPtr lptcomp;
+
+		/// <summary>Represents a pointer to a <see cref="T:System.Runtime.InteropServices.VARDESC" /> structure.</summary>
+		// Token: 0x04000BEB RID: 3051
+		[FieldOffset(0)]
+		public IntPtr lpvardesc;
+	}
+}

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

@@ -0,0 +1,25 @@
+using System;
+
+namespace System.Runtime.InteropServices.ComTypes
+{
+	/// <summary>Stores the parameters that are used during a moniker binding operation.</summary>
+	// Token: 0x020002BC RID: 700
+	public struct BIND_OPTS
+	{
+		/// <summary>Specifies the size, in bytes, of the BIND_OPTS structure.</summary>
+		// Token: 0x04000BEC RID: 3052
+		public int cbStruct;
+
+		/// <summary>Controls aspects of moniker binding operations.</summary>
+		// Token: 0x04000BED RID: 3053
+		public int grfFlags;
+
+		/// <summary>Represents flags that should be used when opening the file that contains the object identified by the moniker.</summary>
+		// Token: 0x04000BEE RID: 3054
+		public int grfMode;
+
+		/// <summary>Indicates the amount of time (clock time in milliseconds, as returned by the GetTickCount function) that the caller specified to complete the binding operation.</summary>
+		// Token: 0x04000BEF RID: 3055
+		public int dwTickCountDeadline;
+	}
+}

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

@@ -0,0 +1,41 @@
+using System;
+
+namespace System.Runtime.InteropServices.ComTypes
+{
+	/// <summary>Identifies the calling convention used by a method described in a METHODDATA structure.</summary>
+	// Token: 0x020002BD RID: 701
+	[Serializable]
+	public enum CALLCONV
+	{
+		/// <summary>Indicates that the C declaration (CDECL) calling convention is used for a method. </summary>
+		// Token: 0x04000BF1 RID: 3057
+		CC_CDECL = 1,
+		/// <summary>Indicates that the Pascal calling convention is used for a method.</summary>
+		// Token: 0x04000BF2 RID: 3058
+		CC_PASCAL,
+		/// <summary>Indicates that the MSC Pascal (MSCPASCAL) calling convention is used for a method.</summary>
+		// Token: 0x04000BF3 RID: 3059
+		CC_MSCPASCAL = 2,
+		/// <summary>Indicates that the Macintosh Pascal (MACPASCAL) calling convention is used for a method.</summary>
+		// Token: 0x04000BF4 RID: 3060
+		CC_MACPASCAL,
+		/// <summary>Indicates that the standard calling convention (STDCALL) is used for a method.</summary>
+		// Token: 0x04000BF5 RID: 3061
+		CC_STDCALL,
+		/// <summary>This value is reserved for future use.</summary>
+		// Token: 0x04000BF6 RID: 3062
+		CC_RESERVED,
+		/// <summary>Indicates that the standard SYSCALL calling convention is used for a method.</summary>
+		// Token: 0x04000BF7 RID: 3063
+		CC_SYSCALL,
+		/// <summary>Indicates that the Macintosh Programmers' Workbench (MPW) CDECL calling convention is used for a method.</summary>
+		// Token: 0x04000BF8 RID: 3064
+		CC_MPWCDECL,
+		/// <summary>Indicates that the Macintosh Programmers' Workbench (MPW) PASCAL calling convention is used for a method.</summary>
+		// Token: 0x04000BF9 RID: 3065
+		CC_MPWPASCAL,
+		/// <summary>Indicates the end of the <see cref="T:System.Runtime.InteropServices.ComTypes.CALLCONV" /> enumeration.</summary>
+		// Token: 0x04000BFA RID: 3066
+		CC_MAX
+	}
+}

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

@@ -0,0 +1,19 @@
+using System;
+
+namespace System.Runtime.InteropServices.ComTypes
+{
+	/// <summary>Describes a connection that exists to a given connection point.</summary>
+	// Token: 0x020002BE RID: 702
+	[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+	public struct CONNECTDATA
+	{
+		/// <summary>Represents a pointer to the IUnknown interface on a connected advisory sink. The caller must call IUnknown::Release on this pointer when the CONNECTDATA structure is no longer needed.</summary>
+		// Token: 0x04000BFB RID: 3067
+		[MarshalAs(UnmanagedType.Interface)]
+		public object pUnk;
+
+		/// <summary>Represents a connection token that is returned from a call to <see cref="M:System.Runtime.InteropServices.ComTypes.IConnectionPoint.Advise(System.Object,System.Int32@)" />.</summary>
+		// Token: 0x04000BFC RID: 3068
+		public int dwCookie;
+	}
+}

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

@@ -0,0 +1,29 @@
+using System;
+
+namespace System.Runtime.InteropServices.ComTypes
+{
+	/// <summary>Identifies the type description being bound to.</summary>
+	// Token: 0x020002BF RID: 703
+	[Serializable]
+	public enum DESCKIND
+	{
+		/// <summary>Indicates that no match was found.</summary>
+		// Token: 0x04000BFE RID: 3070
+		DESCKIND_NONE,
+		/// <summary>Indicates that a <see cref="T:System.Runtime.InteropServices.FUNCDESC" /> structure was returned.</summary>
+		// Token: 0x04000BFF RID: 3071
+		DESCKIND_FUNCDESC,
+		/// <summary>Indicates that a VARDESC was returned.</summary>
+		// Token: 0x04000C00 RID: 3072
+		DESCKIND_VARDESC,
+		/// <summary>Indicates that a TYPECOMP was returned.</summary>
+		// Token: 0x04000C01 RID: 3073
+		DESCKIND_TYPECOMP,
+		/// <summary>Indicates that an IMPLICITAPPOBJ was returned.</summary>
+		// Token: 0x04000C02 RID: 3074
+		DESCKIND_IMPLICITAPPOBJ,
+		/// <summary>Indicates an end-of-enumeration marker.</summary>
+		// Token: 0x04000C03 RID: 3075
+		DESCKIND_MAX
+	}
+}

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

@@ -0,0 +1,26 @@
+using System;
+
+namespace System.Runtime.InteropServices.ComTypes
+{
+	/// <summary>Contains the arguments passed to a method or property by IDispatch::Invoke.</summary>
+	// Token: 0x020002C0 RID: 704
+	[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+	public struct DISPPARAMS
+	{
+		/// <summary>Represents a reference to the array of arguments.</summary>
+		// Token: 0x04000C04 RID: 3076
+		public IntPtr rgvarg;
+
+		/// <summary>Represents the dispatch IDs of named arguments.</summary>
+		// Token: 0x04000C05 RID: 3077
+		public IntPtr rgdispidNamedArgs;
+
+		/// <summary>Represents the count of arguments.</summary>
+		// Token: 0x04000C06 RID: 3078
+		public int cArgs;
+
+		/// <summary>Represents the count of named arguments </summary>
+		// Token: 0x04000C07 RID: 3079
+		public int cNamedArgs;
+	}
+}

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

@@ -0,0 +1,34 @@
+using System;
+
+namespace System.Runtime.InteropServices.ComTypes
+{
+	/// <summary>Contains the type description and process transfer information for a variable, function, or a function parameter.</summary>
+	// Token: 0x020002C1 RID: 705
+	[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+	public struct ELEMDESC
+	{
+		/// <summary>Identifies the type of the element.</summary>
+		// Token: 0x04000C08 RID: 3080
+		public TYPEDESC tdesc;
+
+		/// <summary>Contains information about an element.</summary>
+		// Token: 0x04000C09 RID: 3081
+		public ELEMDESC.DESCUNION desc;
+
+		/// <summary>Contains information about an element. </summary>
+		// Token: 0x020002C2 RID: 706
+		[StructLayout(LayoutKind.Explicit, CharSet = CharSet.Unicode)]
+		public struct DESCUNION
+		{
+			/// <summary>Contains information for remoting the element.</summary>
+			// Token: 0x04000C0A RID: 3082
+			[FieldOffset(0)]
+			public IDLDESC idldesc;
+
+			/// <summary>Contains information about the parameter.</summary>
+			// Token: 0x04000C0B RID: 3083
+			[FieldOffset(0)]
+			public PARAMDESC paramdesc;
+		}
+	}
+}

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

@@ -0,0 +1,49 @@
+using System;
+
+namespace System.Runtime.InteropServices.ComTypes
+{
+	/// <summary>Describes the exceptions that occur during IDispatch::Invoke.</summary>
+	// Token: 0x020002C3 RID: 707
+	[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+	public struct EXCEPINFO
+	{
+		/// <summary>Represents an error code identifying the error.</summary>
+		// Token: 0x04000C0C RID: 3084
+		public short wCode;
+
+		/// <summary>This field is reserved; it must be set to 0.</summary>
+		// Token: 0x04000C0D RID: 3085
+		public short wReserved;
+
+		/// <summary>Indicates the name of the source of the exception. Typically, this is an application name.</summary>
+		// Token: 0x04000C0E RID: 3086
+		[MarshalAs(UnmanagedType.BStr)]
+		public string bstrSource;
+
+		/// <summary>Describes the error intended for the customer.</summary>
+		// Token: 0x04000C0F RID: 3087
+		[MarshalAs(UnmanagedType.BStr)]
+		public string bstrDescription;
+
+		/// <summary>Contains the fully-qualified drive, path, and file name of a Help file that contains more information about the error.</summary>
+		// Token: 0x04000C10 RID: 3088
+		[MarshalAs(UnmanagedType.BStr)]
+		public string bstrHelpFile;
+
+		/// <summary>Indicates the Help context ID of the topic within the Help file.</summary>
+		// Token: 0x04000C11 RID: 3089
+		public int dwHelpContext;
+
+		/// <summary>This field is reserved; it must be set to null.</summary>
+		// Token: 0x04000C12 RID: 3090
+		public IntPtr pvReserved;
+
+		/// <summary>Represents a pointer to a function that takes an <see cref="T:System.Runtime.InteropServices.EXCEPINFO" /> structure as an argument and returns an HRESULT value. If deferred fill-in is not desired, this field is set to null.</summary>
+		// Token: 0x04000C13 RID: 3091
+		public IntPtr pfnDeferredFillIn;
+
+		/// <summary>A return value describing the error.</summary>
+		// Token: 0x04000C14 RID: 3092
+		public int scode;
+	}
+}

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

@@ -0,0 +1,17 @@
+using System;
+
+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: 0x020002C4 RID: 708
+	public struct FILETIME
+	{
+		/// <summary>Specifies the low 32 bits of the FILETIME.</summary>
+		// Token: 0x04000C15 RID: 3093
+		public int dwLowDateTime;
+
+		/// <summary>Specifies the high 32 bits of the FILETIME.</summary>
+		// Token: 0x04000C16 RID: 3094
+		public int dwHighDateTime;
+	}
+}

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

@@ -0,0 +1,57 @@
+using System;
+
+namespace System.Runtime.InteropServices.ComTypes
+{
+	/// <summary>Defines a function description.</summary>
+	// Token: 0x020002C5 RID: 709
+	public struct FUNCDESC
+	{
+		/// <summary>Identifies the function member ID.</summary>
+		// Token: 0x04000C17 RID: 3095
+		public int memid;
+
+		/// <summary>Stores the count of errors a function can return on a 16-bit system.</summary>
+		// Token: 0x04000C18 RID: 3096
+		public IntPtr lprgscode;
+
+		/// <summary>Indicates the size of <see cref="F:System.Runtime.InteropServices.FUNCDESC.cParams" />.</summary>
+		// Token: 0x04000C19 RID: 3097
+		public IntPtr lprgelemdescParam;
+
+		/// <summary>Specifies whether the function is virtual, static, or dispatch-only.</summary>
+		// Token: 0x04000C1A RID: 3098
+		public FUNCKIND funckind;
+
+		/// <summary>Specifies the type of a property function.</summary>
+		// Token: 0x04000C1B RID: 3099
+		public INVOKEKIND invkind;
+
+		/// <summary>Specifies the calling convention of a function.</summary>
+		// Token: 0x04000C1C RID: 3100
+		public CALLCONV callconv;
+
+		/// <summary>Counts the total number of parameters.</summary>
+		// Token: 0x04000C1D RID: 3101
+		public short cParams;
+
+		/// <summary>Counts the optional parameters.</summary>
+		// Token: 0x04000C1E RID: 3102
+		public short cParamsOpt;
+
+		/// <summary>Specifies the offset in the VTBL for <see cref="F:System.Runtime.InteropServices.FUNCKIND.FUNC_VIRTUAL" />.</summary>
+		// Token: 0x04000C1F RID: 3103
+		public short oVft;
+
+		/// <summary>Counts the permitted return values.</summary>
+		// Token: 0x04000C20 RID: 3104
+		public short cScodes;
+
+		/// <summary>Contains the return type of the function.</summary>
+		// Token: 0x04000C21 RID: 3105
+		public ELEMDESC elemdescFunc;
+
+		/// <summary>Indicates the <see cref="T:System.Runtime.InteropServices.FUNCFLAGS" /> of a function.</summary>
+		// Token: 0x04000C22 RID: 3106
+		public short wFuncFlags;
+	}
+}

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

@@ -0,0 +1,51 @@
+using System;
+
+namespace System.Runtime.InteropServices.ComTypes
+{
+	/// <summary>Identifies the constants that define the properties of a function.</summary>
+	// Token: 0x020002C6 RID: 710
+	[Flags]
+	[Serializable]
+	public enum FUNCFLAGS
+	{
+		/// <summary>The function should not be accessible from macro languages. This flag is intended for system-level functions or functions that type browsers should not display.</summary>
+		// Token: 0x04000C24 RID: 3108
+		FUNCFLAG_FRESTRICTED = 1,
+		/// <summary>The function returns an object that is a source of events.</summary>
+		// Token: 0x04000C25 RID: 3109
+		FUNCFLAG_FSOURCE = 2,
+		/// <summary>The function that supports data binding.</summary>
+		// Token: 0x04000C26 RID: 3110
+		FUNCFLAG_FBINDABLE = 4,
+		/// <summary>When set, any call to a method that sets the property results first in a call to IPropertyNotifySink::OnRequestEdit. The implementation of OnRequestEdit determines if the call is allowed to set the property.</summary>
+		// Token: 0x04000C27 RID: 3111
+		FUNCFLAG_FREQUESTEDIT = 8,
+		/// <summary>The function that is displayed to the user as bindable. <see cref="F:System.Runtime.InteropServices.FUNCFLAGS.FUNCFLAG_FBINDABLE" /> must also be set.</summary>
+		// Token: 0x04000C28 RID: 3112
+		FUNCFLAG_FDISPLAYBIND = 16,
+		/// <summary>The function that best represents the object. Only one function in a type can have this attribute.</summary>
+		// Token: 0x04000C29 RID: 3113
+		FUNCFLAG_FDEFAULTBIND = 32,
+		/// <summary>The function should not be displayed to the user, although it exists and is bindable.</summary>
+		// Token: 0x04000C2A RID: 3114
+		FUNCFLAG_FHIDDEN = 64,
+		/// <summary>The function supports GetLastError. If an error occurs during the function, the caller can call GetLastError to retrieve the error code.</summary>
+		// Token: 0x04000C2B RID: 3115
+		FUNCFLAG_FUSESGETLASTERROR = 128,
+		/// <summary>Permits an optimization in which the compiler looks for a member named "xyz" on the type of "abc". If such a member is found, and is flagged as an accessor function for an element of the default collection, a call is generated to that member function. Permitted on members in dispinterfaces and interfaces; not permitted on modules.</summary>
+		// Token: 0x04000C2C RID: 3116
+		FUNCFLAG_FDEFAULTCOLLELEM = 256,
+		/// <summary>The type information member is the default member for display in the user interface.</summary>
+		// Token: 0x04000C2D RID: 3117
+		FUNCFLAG_FUIDEFAULT = 512,
+		/// <summary>The property appears in an object browser, but not in a properties browser.</summary>
+		// Token: 0x04000C2E RID: 3118
+		FUNCFLAG_FNONBROWSABLE = 1024,
+		/// <summary>Tags the interface as having default behaviors.</summary>
+		// Token: 0x04000C2F RID: 3119
+		FUNCFLAG_FREPLACEABLE = 2048,
+		/// <summary>Mapped as individual bindable properties.</summary>
+		// Token: 0x04000C30 RID: 3120
+		FUNCFLAG_FIMMEDIATEBIND = 4096
+	}
+}

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

@@ -0,0 +1,26 @@
+using System;
+
+namespace System.Runtime.InteropServices.ComTypes
+{
+	/// <summary>Defines how to access a function.</summary>
+	// Token: 0x020002C7 RID: 711
+	[Serializable]
+	public enum FUNCKIND
+	{
+		/// <summary>The function is accessed in the same way as <see cref="F:System.Runtime.InteropServices.FUNCKIND.FUNC_PUREVIRTUAL" />, except the function has an implementation.</summary>
+		// Token: 0x04000C32 RID: 3122
+		FUNC_VIRTUAL,
+		/// <summary>The function is accessed through the virtual function table (VTBL), and takes an implicit this pointer.</summary>
+		// Token: 0x04000C33 RID: 3123
+		FUNC_PUREVIRTUAL,
+		/// <summary>The function is accessed by static address and takes an implicit this pointer.</summary>
+		// Token: 0x04000C34 RID: 3124
+		FUNC_NONVIRTUAL,
+		/// <summary>The function is accessed by static address and does not take an implicit this pointer.</summary>
+		// Token: 0x04000C35 RID: 3125
+		FUNC_STATIC,
+		/// <summary>The function can be accessed only through IDispatch.</summary>
+		// Token: 0x04000C36 RID: 3126
+		FUNC_DISPATCH
+	}
+}

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

@@ -0,0 +1,65 @@
+using System;
+
+namespace System.Runtime.InteropServices.ComTypes
+{
+	/// <summary>Provides the managed definition of the IBindCtx interface.</summary>
+	// Token: 0x020002C8 RID: 712
+	[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+	[Guid("0000000e-0000-0000-c000-000000000046")]
+	[ComImport]
+	public interface IBindCtx
+	{
+		/// <summary>Registers the passed object as one of the objects that has been bound during a moniker operation and that should be released when the operation is complete.</summary>
+		/// <param name="punk">The object to register for release. </param>
+		// Token: 0x0600210F RID: 8463
+		void RegisterObjectBound([MarshalAs(UnmanagedType.Interface)] object punk);
+
+		/// <summary>Removes the object from the set of registered objects that need to be released.</summary>
+		/// <param name="punk">The object to unregister for release. </param>
+		// Token: 0x06002110 RID: 8464
+		void RevokeObjectBound([MarshalAs(UnmanagedType.Interface)] object punk);
+
+		/// <summary>Releases all the objects currently registered with the bind context by using the <see cref="M:System.Runtime.InteropServices.ComTypes.IBindCtx.RegisterObjectBound(System.Object)" /> method.</summary>
+		// Token: 0x06002111 RID: 8465
+		void ReleaseBoundObjects();
+
+		/// <summary>Stores a block of parameters in the bind context. These parameters will apply to later UCOMIMoniker operations that use this bind context.</summary>
+		/// <param name="pbindopts">The structure containing the binding options to set. </param>
+		// Token: 0x06002112 RID: 8466
+		void SetBindOptions([In] ref BIND_OPTS pbindopts);
+
+		/// <summary>Returns the current binding options stored in the current bind context.</summary>
+		/// <param name="pbindopts">A pointer to the structure to receive the binding options. </param>
+		// Token: 0x06002113 RID: 8467
+		void GetBindOptions(ref BIND_OPTS pbindopts);
+
+		/// <summary>Returns access to the Running Object Table (ROT) relevant to this binding process.</summary>
+		/// <param name="pprot">When this method returns, contains a reference to the Running Object Table (ROT). This parameter is passed uninitialized.</param>
+		// Token: 0x06002114 RID: 8468
+		void GetRunningObjectTable(out IRunningObjectTable pprot);
+
+		/// <summary>Registers the specified object pointer under the specified name in the internally maintained table of object pointers.</summary>
+		/// <param name="pszKey">The name to register <paramref name="punk" /> with. </param>
+		/// <param name="punk">The object to register. </param>
+		// Token: 0x06002115 RID: 8469
+		void RegisterObjectParam([MarshalAs(UnmanagedType.LPWStr)] string pszKey, [MarshalAs(UnmanagedType.Interface)] object punk);
+
+		/// <summary>Looks up the given key in the internally maintained table of contextual object parameters and returns the corresponding object, if one exists.</summary>
+		/// <param name="pszKey">The name of the object to search for. </param>
+		/// <param name="ppunk">When this method returns, contains the object interface pointer. This parameter is passed uninitialized.</param>
+		// Token: 0x06002116 RID: 8470
+		void GetObjectParam([MarshalAs(UnmanagedType.LPWStr)] string pszKey, [MarshalAs(UnmanagedType.Interface)] out object ppunk);
+
+		/// <summary>Enumerates the strings that are the keys of the internally maintained table of contextual object parameters.</summary>
+		/// <param name="ppenum">When this method returns, contains a reference to the object parameter enumerator. This parameter is passed uninitialized.</param>
+		// Token: 0x06002117 RID: 8471
+		void EnumObjectParam(out IEnumString ppenum);
+
+		/// <summary>Revokes the registration of the object currently found under the specified key in the internally maintained table of contextual object parameters, if that key is currently registered.</summary>
+		/// <returns>An S_OKHRESULT value if the specified key was successfully removed from the table; otherwise, an S_FALSEHRESULT value.</returns>
+		/// <param name="pszKey">The key to unregister. </param>
+		// Token: 0x06002118 RID: 8472
+		[PreserveSig]
+		int RevokeObjectParam([MarshalAs(UnmanagedType.LPWStr)] string pszKey);
+	}
+}

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

@@ -0,0 +1,38 @@
+using System;
+
+namespace System.Runtime.InteropServices.ComTypes
+{
+	/// <summary>Provides the managed definition of the IConnectionPoint interface.</summary>
+	// Token: 0x020002C9 RID: 713
+	[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+	[Guid("b196b286-bab4-101a-b69c-00aa00341d07")]
+	[ComImport]
+	public interface IConnectionPoint
+	{
+		/// <summary>Returns the IID of the outgoing interface managed by this connection point.</summary>
+		/// <param name="pIID">When this parameter returns, contains the IID of the outgoing interface managed by this connection point. This parameter is passed uninitialized.</param>
+		// Token: 0x06002119 RID: 8473
+		void GetConnectionInterface(out Guid pIID);
+
+		/// <summary>Retrieves the IConnectionPointContainer interface pointer to the connectable object that conceptually owns this connection point.</summary>
+		/// <param name="ppCPC">When this parameter returns, contains the connectable object's IConnectionPointContainer interface. This parameter is passed uninitialized.</param>
+		// Token: 0x0600211A RID: 8474
+		void GetConnectionPointContainer(out IConnectionPointContainer ppCPC);
+
+		/// <summary>Establishes an advisory connection between the connection point and the caller's sink object.</summary>
+		/// <param name="pUnkSink">A reference to the sink to receive calls for the outgoing interface managed by this connection point. </param>
+		/// <param name="pdwCookie">When this method returns, contains the connection cookie. This parameter is passed uninitialized.</param>
+		// Token: 0x0600211B RID: 8475
+		void Advise([MarshalAs(UnmanagedType.Interface)] object pUnkSink, out int pdwCookie);
+
+		/// <summary>Terminates an advisory connection previously established through the <see cref="M:System.Runtime.InteropServices.ComTypes.IConnectionPoint.Advise(System.Object,System.Int32@)" /> method.</summary>
+		/// <param name="dwCookie">The connection cookie previously returned from the <see cref="M:System.Runtime.InteropServices.ComTypes.IConnectionPoint.Advise(System.Object,System.Int32@)" /> method. </param>
+		// Token: 0x0600211C RID: 8476
+		void Unadvise(int dwCookie);
+
+		/// <summary>Creates an enumerator object for iteration through the connections that exist to this connection point.</summary>
+		/// <param name="ppEnum">When this method returns, contains the newly created enumerator. This parameter is passed uninitialized.</param>
+		// Token: 0x0600211D RID: 8477
+		void EnumConnections(out IEnumConnections ppEnum);
+	}
+}

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

@@ -0,0 +1,23 @@
+using System;
+
+namespace System.Runtime.InteropServices.ComTypes
+{
+	/// <summary>Provides the managed definition of the IConnectionPointContainer interface.</summary>
+	// Token: 0x020002CA RID: 714
+	[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+	[Guid("b196b284-bab4-101a-b69c-00aa00341d07")]
+	[ComImport]
+	public interface IConnectionPointContainer
+	{
+		/// <summary>Creates an enumerator of all the connection points supported in the connectable object, one connection point per IID.</summary>
+		/// <param name="ppEnum">When this method returns, contains the interface pointer of the enumerator. This parameter is passed uninitialized.</param>
+		// Token: 0x0600211E RID: 8478
+		void EnumConnectionPoints(out IEnumConnectionPoints ppEnum);
+
+		/// <summary>Asks the connectable object if it has a connection point for a particular IID, and if so, returns the IConnectionPoint interface pointer to that connection point.</summary>
+		/// <param name="riid">A reference to the outgoing interface IID whose connection point is being requested. </param>
+		/// <param name="ppCP">When this method returns, contains the connection point that manages the outgoing interface <paramref name="riid" />. This parameter is passed uninitialized.</param>
+		// Token: 0x0600211F RID: 8479
+		void FindConnectionPoint([In] ref Guid riid, out IConnectionPoint ppCP);
+	}
+}