a

mscorlib/Cpp2IlInjected/AddressAttribute.cs

@@ -0,0 +1,20 @@
+using System;
+
+namespace Cpp2IlInjected
+{
+	// Token: 0x020006E0 RID: 1760
+	internal class AddressAttribute : Attribute
+	{
+		// Token: 0x04001CA7 RID: 7335
+		public string RVA;
+
+		// Token: 0x04001CA8 RID: 7336
+		public string Offset;
+
+		// Token: 0x04001CA9 RID: 7337
+		public string VA;
+
+		// Token: 0x04001CAA RID: 7338
+		public string Slot;
+	}
+}

mscorlib/Cpp2IlInjected/AnalysisFailedException.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace Cpp2IlInjected
+{
+	// Token: 0x020006E5 RID: 1765
+	internal class AnalysisFailedException : Exception
+	{
+		// Token: 0x0600322F RID: 12847
+		public extern AnalysisFailedException(string message);
+	}
+}

mscorlib/Cpp2IlInjected/AttributeAttribute.cs

@@ -0,0 +1,17 @@
+using System;
+
+namespace Cpp2IlInjected
+{
+	// Token: 0x020006E2 RID: 1762
+	internal class AttributeAttribute : Attribute
+	{
+		// Token: 0x04001CAC RID: 7340
+		public string Name;
+
+		// Token: 0x04001CAD RID: 7341
+		public string RVA;
+
+		// Token: 0x04001CAE RID: 7342
+		public string Offset;
+	}
+}

mscorlib/Cpp2IlInjected/FieldOffsetAttribute.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace Cpp2IlInjected
+{
+	// Token: 0x020006E1 RID: 1761
+	internal class FieldOffsetAttribute : Attribute
+	{
+		// Token: 0x04001CAB RID: 7339
+		public string Offset;
+	}
+}

mscorlib/Cpp2IlInjected/MetadataOffsetAttribute.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace Cpp2IlInjected
+{
+	// Token: 0x020006E3 RID: 1763
+	internal class MetadataOffsetAttribute : Attribute
+	{
+		// Token: 0x04001CAF RID: 7343
+		public string Offset;
+	}
+}

mscorlib/Cpp2IlInjected/TokenAttribute.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace Cpp2IlInjected
+{
+	// Token: 0x020006E4 RID: 1764
+	internal class TokenAttribute : Attribute
+	{
+		// Token: 0x04001CB0 RID: 7344
+		public string Token;
+	}
+}

mscorlib/Locale.cs

@@ -0,0 +1,23 @@
+using System;
+using Cpp2IlInjected;
+
+// Token: 0x02000003 RID: 3
+[Token(Token = "0x2000003")]
+internal sealed class Locale
+{
+	// Token: 0x06000005 RID: 5 RVA: 0x00002082 File Offset: 0x00000282
+	[Token(Token = "0x6000005")]
+	[Address(RVA = "0x434BD0", Offset = "0x4339D0", VA = "0x180434BD0")]
+	public static string GetText(string msg)
+	{
+		return null;
+	}
+
+	// Token: 0x06000006 RID: 6 RVA: 0x00002082 File Offset: 0x00000282
+	[Token(Token = "0x6000006")]
+	[Address(RVA = "0x68A9B0", Offset = "0x6897B0", VA = "0x18068A9B0")]
+	public static string GetText(string fmt, params object[] args)
+	{
+		return null;
+	}
+}

mscorlib/Microsoft/Reflection/ReflectionExtensions.cs

@@ -0,0 +1,67 @@
+using System;
+using System.Reflection;
+using Cpp2IlInjected;
+
+namespace Microsoft.Reflection
+{
+	// Token: 0x02000058 RID: 88
+	[Token(Token = "0x2000058")]
+	internal static class ReflectionExtensions
+	{
+		// Token: 0x06000278 RID: 632 RVA: 0x00003138 File Offset: 0x00001338
+		[Token(Token = "0x6000278")]
+		[Address(RVA = "0x18DD4E0", Offset = "0x18DC2E0", VA = "0x1818DD4E0")]
+		public static bool IsEnum(this Type type)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x06000279 RID: 633 RVA: 0x00003150 File Offset: 0x00001350
+		[Token(Token = "0x6000279")]
+		[Address(RVA = "0x2AB2F80", Offset = "0x2AB1D80", VA = "0x182AB2F80")]
+		public static bool IsAbstract(this Type type)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x0600027A RID: 634 RVA: 0x00003168 File Offset: 0x00001368
+		[Token(Token = "0x600027A")]
+		[Address(RVA = "0x2AB2FA0", Offset = "0x2AB1DA0", VA = "0x182AB2FA0")]
+		public static bool IsSealed(this Type type)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x0600027B RID: 635 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x600027B")]
+		[Address(RVA = "0x2AB2EF0", Offset = "0x2AB1CF0", VA = "0x182AB2EF0")]
+		public static Type BaseType(this Type type)
+		{
+			return null;
+		}
+
+		// Token: 0x0600027C RID: 636 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x600027C")]
+		[Address(RVA = "0x2AB2EC0", Offset = "0x2AB1CC0", VA = "0x182AB2EC0")]
+		public static Assembly Assembly(this Type type)
+		{
+			return null;
+		}
+
+		// Token: 0x0600027D RID: 637 RVA: 0x00003180 File Offset: 0x00001380
+		[Token(Token = "0x600027D")]
+		[Address(RVA = "0x2AB2F20", Offset = "0x2AB1D20", VA = "0x182AB2F20")]
+		public static TypeCode GetTypeCode(this Type type)
+		{
+			return TypeCode.Empty;
+		}
+
+		// Token: 0x0600027E RID: 638 RVA: 0x00003198 File Offset: 0x00001398
+		[Token(Token = "0x600027E")]
+		[Address(RVA = "0x2AB2FC0", Offset = "0x2AB1DC0", VA = "0x182AB2FC0")]
+		public static bool ReflectionOnly(this Assembly assm)
+		{
+			return default(bool);
+		}
+	}
+}

mscorlib/Microsoft/Win32/ExpandString.cs

@@ -0,0 +1,38 @@
+using System;
+using Cpp2IlInjected;
+
+namespace Microsoft.Win32
+{
+	// Token: 0x02000069 RID: 105
+	[Token(Token = "0x2000069")]
+	internal class ExpandString
+	{
+		// Token: 0x060002B0 RID: 688 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60002B0")]
+		[Address(RVA = "0x3FFB80", Offset = "0x3FE980", VA = "0x1803FFB80")]
+		public ExpandString(string s)
+		{
+		}
+
+		// Token: 0x060002B1 RID: 689 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60002B1")]
+		[Address(RVA = "0x3F6E20", Offset = "0x3F5C20", VA = "0x1803F6E20", Slot = "3")]
+		public override string ToString()
+		{
+			return null;
+		}
+
+		// Token: 0x060002B2 RID: 690 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60002B2")]
+		[Address(RVA = "0x2AA8A10", Offset = "0x2AA7810", VA = "0x182AA8A10")]
+		public string Expand()
+		{
+			return null;
+		}
+
+		// Token: 0x040001A3 RID: 419
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x40001A3")]
+		private string value;
+	}
+}

mscorlib/Microsoft/Win32/IRegistryApi.cs

@@ -0,0 +1,55 @@
+using System;
+using Cpp2IlInjected;
+
+namespace Microsoft.Win32
+{
+	// Token: 0x02000063 RID: 99
+	[Token(Token = "0x2000063")]
+	internal interface IRegistryApi
+	{
+		// Token: 0x0600028A RID: 650
+		[Token(Token = "0x600028A")]
+		[Address(Slot = "0")]
+		RegistryKey CreateSubKey(RegistryKey rkey, string keyname);
+
+		// Token: 0x0600028B RID: 651
+		[Token(Token = "0x600028B")]
+		[Address(Slot = "1")]
+		RegistryKey OpenSubKey(RegistryKey rkey, string keyname, bool writtable);
+
+		// Token: 0x0600028C RID: 652
+		[Token(Token = "0x600028C")]
+		[Address(Slot = "2")]
+		void Flush(RegistryKey rkey);
+
+		// Token: 0x0600028D RID: 653
+		[Token(Token = "0x600028D")]
+		[Address(Slot = "3")]
+		void Close(RegistryKey rkey);
+
+		// Token: 0x0600028E RID: 654
+		[Token(Token = "0x600028E")]
+		[Address(Slot = "4")]
+		object GetValue(RegistryKey rkey, string name, object default_value, RegistryValueOptions options);
+
+		// Token: 0x0600028F RID: 655
+		[Token(Token = "0x600028F")]
+		[Address(Slot = "5")]
+		void SetValue(RegistryKey rkey, string name, object value);
+
+		// Token: 0x06000290 RID: 656
+		[Token(Token = "0x6000290")]
+		[Address(Slot = "6")]
+		string[] GetSubKeyNames(RegistryKey rkey);
+
+		// Token: 0x06000291 RID: 657
+		[Token(Token = "0x6000291")]
+		[Address(Slot = "7")]
+		string ToString(RegistryKey rkey);
+
+		// Token: 0x06000292 RID: 658
+		[Token(Token = "0x6000292")]
+		[Address(Slot = "8")]
+		IntPtr GetHandle(RegistryKey key);
+	}
+}

mscorlib/Microsoft/Win32/KeyHandler.cs

@@ -0,0 +1,291 @@
+using System;
+using System.Collections;
+using System.Security;
+using Cpp2IlInjected;
+
+namespace Microsoft.Win32
+{
+	// Token: 0x0200006B RID: 107
+	[Token(Token = "0x200006B")]
+	internal class KeyHandler
+	{
+		// Token: 0x060002B7 RID: 695 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60002B7")]
+		[Address(RVA = "0x2AAE8B0", Offset = "0x2AAD6B0", VA = "0x182AAE8B0")]
+		private KeyHandler(RegistryKey rkey, string basedir)
+		{
+		}
+
+		// Token: 0x060002B8 RID: 696 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60002B8")]
+		[Address(RVA = "0x2AAE740", Offset = "0x2AAD540", VA = "0x182AAE740")]
+		private KeyHandler(RegistryKey rkey, string basedir, bool is_volatile)
+		{
+		}
+
+		// Token: 0x060002B9 RID: 697 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60002B9")]
+		[Address(RVA = "0x2AACAC0", Offset = "0x2AAB8C0", VA = "0x182AACAC0")]
+		public void Load()
+		{
+		}
+
+		// Token: 0x060002BA RID: 698 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60002BA")]
+		[Address(RVA = "0x2AAC650", Offset = "0x2AAB450", VA = "0x182AAC650")]
+		private void LoadKey(SecurityElement se)
+		{
+		}
+
+		// Token: 0x060002BB RID: 699 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60002BB")]
+		[Address(RVA = "0x2AAB500", Offset = "0x2AAA300", VA = "0x182AAB500")]
+		public RegistryKey Ensure(RegistryKey rkey, string extra, bool writable, bool is_volatile)
+		{
+			return null;
+		}
+
+		// Token: 0x060002BC RID: 700 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60002BC")]
+		[Address(RVA = "0x2AAD3D0", Offset = "0x2AAC1D0", VA = "0x182AAD3D0")]
+		public RegistryKey Probe(RegistryKey rkey, string extra, bool writable)
+		{
+			return null;
+		}
+
+		// Token: 0x060002BD RID: 701 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60002BD")]
+		[Address(RVA = "0x2AAB040", Offset = "0x2AA9E40", VA = "0x182AAB040")]
+		private static string CombineName(RegistryKey rkey, string extra)
+		{
+			return null;
+		}
+
+		// Token: 0x060002BE RID: 702 RVA: 0x00003258 File Offset: 0x00001458
+		[Token(Token = "0x60002BE")]
+		[Address(RVA = "0x2AAC0F0", Offset = "0x2AAAEF0", VA = "0x182AAC0F0")]
+		private static long GetSystemBootTime()
+		{
+			return 0L;
+		}
+
+		// Token: 0x060002BF RID: 703 RVA: 0x00003270 File Offset: 0x00001470
+		[Token(Token = "0x60002BF")]
+		[Address(RVA = "0x2AAB930", Offset = "0x2AAA730", VA = "0x182AAB930")]
+		private static long GetRegisteredBootTime(string path)
+		{
+			return 0L;
+		}
+
+		// Token: 0x060002C0 RID: 704 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60002C0")]
+		[Address(RVA = "0x2AAD770", Offset = "0x2AAC570", VA = "0x182AAD770")]
+		private static void SaveRegisteredBootTime(string path, long btime)
+		{
+		}
+
+		// Token: 0x060002C1 RID: 705 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60002C1")]
+		[Address(RVA = "0x2AAADE0", Offset = "0x2AA9BE0", VA = "0x182AAADE0")]
+		private static void CleanVolatileKeys()
+		{
+		}
+
+		// Token: 0x060002C2 RID: 706 RVA: 0x00003288 File Offset: 0x00001488
+		[Token(Token = "0x60002C2")]
+		[Address(RVA = "0x2AAE400", Offset = "0x2AAD200", VA = "0x182AAE400")]
+		public static bool VolatileKeyExists(string dir)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x060002C3 RID: 707 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60002C3")]
+		[Address(RVA = "0x2AAC480", Offset = "0x2AAB280", VA = "0x182AAC480")]
+		public static string GetVolatileDir(string dir)
+		{
+			return null;
+		}
+
+		// Token: 0x060002C4 RID: 708 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60002C4")]
+		[Address(RVA = "0x2AACEB0", Offset = "0x2AABCB0", VA = "0x182AACEB0")]
+		public static KeyHandler Lookup(RegistryKey rkey, bool createNonExisting)
+		{
+			return null;
+		}
+
+		// Token: 0x060002C5 RID: 709 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60002C5")]
+		[Address(RVA = "0x2AABAE0", Offset = "0x2AAA8E0", VA = "0x182AABAE0")]
+		private static string GetRootFromDir(string dir)
+		{
+			return null;
+		}
+
+		// Token: 0x060002C6 RID: 710 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60002C6")]
+		[Address(RVA = "0x2AAB0E0", Offset = "0x2AA9EE0", VA = "0x182AAB0E0")]
+		public static void Drop(RegistryKey rkey)
+		{
+		}
+
+		// Token: 0x060002C7 RID: 711 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60002C7")]
+		[Address(RVA = "0x2AAC2E0", Offset = "0x2AAB0E0", VA = "0x182AAC2E0")]
+		public object GetValue(string name, RegistryValueOptions options)
+		{
+			return null;
+		}
+
+		// Token: 0x060002C8 RID: 712 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60002C8")]
+		[Address(RVA = "0x2AAE0E0", Offset = "0x2AACEE0", VA = "0x182AAE0E0")]
+		public void SetValue(string name, object value)
+		{
+		}
+
+		// Token: 0x060002C9 RID: 713 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60002C9")]
+		[Address(RVA = "0x2AABC20", Offset = "0x2AAAA20", VA = "0x182AABC20")]
+		public string[] GetSubKeyNames()
+		{
+			return null;
+		}
+
+		// Token: 0x060002CA RID: 714 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60002CA")]
+		[Address(RVA = "0x2AADFA0", Offset = "0x2AACDA0", VA = "0x182AADFA0")]
+		private void SetDirty()
+		{
+		}
+
+		// Token: 0x060002CB RID: 715 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60002CB")]
+		[Address(RVA = "0x2AAB0D0", Offset = "0x2AA9ED0", VA = "0x182AAB0D0")]
+		public void DirtyTimeout(object state)
+		{
+		}
+
+		// Token: 0x060002CC RID: 716 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60002CC")]
+		[Address(RVA = "0x2AAB840", Offset = "0x2AAA640", VA = "0x182AAB840")]
+		public void Flush()
+		{
+		}
+
+		// Token: 0x060002CD RID: 717 RVA: 0x000032A0 File Offset: 0x000014A0
+		[Token(Token = "0x60002CD")]
+		[Address(RVA = "0x2AAE300", Offset = "0x2AAD100", VA = "0x182AAE300")]
+		public bool ValueExists(string name)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x17000064 RID: 100
+		// (get) Token: 0x060002CE RID: 718 RVA: 0x000032B8 File Offset: 0x000014B8
+		[Token(Token = "0x17000064")]
+		public bool IsMarkedForDeletion
+		{
+			[Token(Token = "0x60002CE")]
+			[Address(RVA = "0x2AAE8D0", Offset = "0x2AAD6D0", VA = "0x182AAE8D0")]
+			get
+			{
+				return default(bool);
+			}
+		}
+
+		// Token: 0x060002CF RID: 719 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60002CF")]
+		[Address(RVA = "0x2AAB7D0", Offset = "0x2AAA5D0", VA = "0x182AAB7D0", Slot = "1")]
+		protected override void Finalize()
+		{
+		}
+
+		// Token: 0x060002D0 RID: 720 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60002D0")]
+		[Address(RVA = "0x2AAD870", Offset = "0x2AAC670", VA = "0x182AAD870")]
+		private void Save()
+		{
+		}
+
+		// Token: 0x060002D1 RID: 721 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60002D1")]
+		[Address(RVA = "0x2AAAD80", Offset = "0x2AA9B80", VA = "0x182AAAD80")]
+		private void AssertNotMarkedForDeletion()
+		{
+		}
+
+		// Token: 0x17000065 RID: 101
+		// (get) Token: 0x060002D2 RID: 722 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x17000065")]
+		private static string UserStore
+		{
+			[Token(Token = "0x60002D2")]
+			[Address(RVA = "0x2AAEB10", Offset = "0x2AAD910", VA = "0x182AAEB10")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x17000066 RID: 102
+		// (get) Token: 0x060002D3 RID: 723 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x17000066")]
+		private static string MachineStore
+		{
+			[Token(Token = "0x60002D3")]
+			[Address(RVA = "0x2AAE960", Offset = "0x2AAD760", VA = "0x182AAE960")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x040001A4 RID: 420
+		[Token(Token = "0x40001A4")]
+		private static Hashtable key_to_handler;
+
+		// Token: 0x040001A5 RID: 421
+		[Token(Token = "0x40001A5")]
+		private static Hashtable dir_to_handler;
+
+		// Token: 0x040001A6 RID: 422
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x40001A6")]
+		public string Dir;
+
+		// Token: 0x040001A7 RID: 423
+		[FieldOffset(Offset = "0x18")]
+		[Token(Token = "0x40001A7")]
+		private string ActualDir;
+
+		// Token: 0x040001A8 RID: 424
+		[FieldOffset(Offset = "0x20")]
+		[Token(Token = "0x40001A8")]
+		public bool IsVolatile;
+
+		// Token: 0x040001A9 RID: 425
+		[FieldOffset(Offset = "0x28")]
+		[Token(Token = "0x40001A9")]
+		private Hashtable values;
+
+		// Token: 0x040001AA RID: 426
+		[FieldOffset(Offset = "0x30")]
+		[Token(Token = "0x40001AA")]
+		private string file;
+
+		// Token: 0x040001AB RID: 427
+		[FieldOffset(Offset = "0x38")]
+		[Token(Token = "0x40001AB")]
+		private bool dirty;
+
+		// Token: 0x040001AC RID: 428
+		[Token(Token = "0x40001AC")]
+		private static string user_store;
+
+		// Token: 0x040001AD RID: 429
+		[Token(Token = "0x40001AD")]
+		private static string machine_store;
+	}
+}

mscorlib/Microsoft/Win32/Registry.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Runtime.InteropServices;
+using Cpp2IlInjected;
+
+namespace Microsoft.Win32
+{
+	/// <summary>Provides <see cref="T:Microsoft.Win32.RegistryKey" /> objects that represent the root keys in the Windows registry, and <see langword="static" /> methods to access key/value pairs.</summary>
+	// Token: 0x02000064 RID: 100
+	[Token(Token = "0x2000064")]
+	[ComVisible(true)]
+	public static class Registry
+	{
+		/// <summary>Defines the types (or classes) of documents and the properties associated with those types. This field reads the Windows registry base key HKEY_CLASSES_ROOT.</summary>
+		// Token: 0x04000181 RID: 385
+		[Token(Token = "0x4000181")]
+		public static readonly RegistryKey ClassesRoot;
+
+		/// <summary>Contains configuration information pertaining to the hardware that is not specific to the user. This field reads the Windows registry base key HKEY_CURRENT_CONFIG.</summary>
+		// Token: 0x04000182 RID: 386
+		[Token(Token = "0x4000182")]
+		public static readonly RegistryKey CurrentConfig;
+
+		/// <summary>Contains information about the current user preferences. This field reads the Windows registry base key HKEY_CURRENT_USER.</summary>
+		// Token: 0x04000183 RID: 387
+		[Token(Token = "0x4000183")]
+		public static readonly RegistryKey CurrentUser;
+
+		/// <summary>Contains dynamic registry data. This field reads the Windows registry base key HKEY_DYN_DATA.</summary>
+		/// <exception cref="T:System.ObjectDisposedException">The operating system does not support dynamic data; that is, it is not Windows 98, Windows 98 Second Edition, or Windows Millennium Edition (Windows Me).</exception>
+		// Token: 0x04000184 RID: 388
+		[Token(Token = "0x4000184")]
+		[Obsolete]
+		public static readonly RegistryKey DynData;
+
+		/// <summary>Contains the configuration data for the local machine. This field reads the Windows registry base key HKEY_LOCAL_MACHINE.</summary>
+		// Token: 0x04000185 RID: 389
+		[Token(Token = "0x4000185")]
+		public static readonly RegistryKey LocalMachine;
+
+		/// <summary>Contains performance information for software components. This field reads the Windows registry base key HKEY_PERFORMANCE_DATA.</summary>
+		// Token: 0x04000186 RID: 390
+		[Token(Token = "0x4000186")]
+		public static readonly RegistryKey PerformanceData;
+
+		/// <summary>Contains information about the default user configuration. This field reads the Windows registry base key HKEY_USERS.</summary>
+		// Token: 0x04000187 RID: 391
+		[Token(Token = "0x4000187")]
+		public static readonly RegistryKey Users;
+	}
+}

mscorlib/Microsoft/Win32/RegistryHive.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Runtime.InteropServices;
+using Cpp2IlInjected;
+
+namespace Microsoft.Win32
+{
+	/// <summary>Represents the possible values for a top-level node on a foreign machine.</summary>
+	// Token: 0x02000065 RID: 101
+	[Token(Token = "0x2000065")]
+	[ComVisible(true)]
+	[Serializable]
+	public enum RegistryHive
+	{
+		/// <summary>Represents the HKEY_CLASSES_ROOT base key on another computer. This value can be passed to the <see cref="M:Microsoft.Win32.RegistryKey.OpenRemoteBaseKey(Microsoft.Win32.RegistryHive,System.String)" /> method, to open this node remotely.</summary>
+		// Token: 0x04000189 RID: 393
+		[Token(Token = "0x4000189")]
+		ClassesRoot = -2147483648,
+		/// <summary>Represents the HKEY_CURRENT_CONFIG base key on another computer. This value can be passed to the <see cref="M:Microsoft.Win32.RegistryKey.OpenRemoteBaseKey(Microsoft.Win32.RegistryHive,System.String)" /> method, to open this node remotely.</summary>
+		// Token: 0x0400018A RID: 394
+		[Token(Token = "0x400018A")]
+		CurrentConfig = -2147483643,
+		/// <summary>Represents the HKEY_CURRENT_USER base key on another computer. This value can be passed to the <see cref="M:Microsoft.Win32.RegistryKey.OpenRemoteBaseKey(Microsoft.Win32.RegistryHive,System.String)" /> method, to open this node remotely.</summary>
+		// Token: 0x0400018B RID: 395
+		[Token(Token = "0x400018B")]
+		CurrentUser = -2147483647,
+		/// <summary>Represents the HKEY_DYN_DATA base key on another computer. This value can be passed to the <see cref="M:Microsoft.Win32.RegistryKey.OpenRemoteBaseKey(Microsoft.Win32.RegistryHive,System.String)" /> method, to open this node remotely.</summary>
+		// Token: 0x0400018C RID: 396
+		[Token(Token = "0x400018C")]
+		DynData = -2147483642,
+		/// <summary>Represents the HKEY_LOCAL_MACHINE base key on another computer. This value can be passed to the <see cref="M:Microsoft.Win32.RegistryKey.OpenRemoteBaseKey(Microsoft.Win32.RegistryHive,System.String)" /> method, to open this node remotely.</summary>
+		// Token: 0x0400018D RID: 397
+		[Token(Token = "0x400018D")]
+		LocalMachine = -2147483646,
+		/// <summary>Represents the HKEY_PERFORMANCE_DATA base key on another computer. This value can be passed to the <see cref="M:Microsoft.Win32.RegistryKey.OpenRemoteBaseKey(Microsoft.Win32.RegistryHive,System.String)" /> method, to open this node remotely.</summary>
+		// Token: 0x0400018E RID: 398
+		[Token(Token = "0x400018E")]
+		PerformanceData = -2147483644,
+		/// <summary>Represents the HKEY_USERS base key on another computer. This value can be passed to the <see cref="M:Microsoft.Win32.RegistryKey.OpenRemoteBaseKey(Microsoft.Win32.RegistryHive,System.String)" /> method, to open this node remotely.</summary>
+		// Token: 0x0400018F RID: 399
+		[Token(Token = "0x400018F")]
+		Users = -2147483645
+	}
+}

mscorlib/Microsoft/Win32/RegistryKey.cs

@@ -0,0 +1,363 @@
+using System;
+using System.IO;
+using System.Runtime.InteropServices;
+using Cpp2IlInjected;
+using Microsoft.Win32.SafeHandles;
+
+namespace Microsoft.Win32
+{
+	/// <summary>Represents a key-level node in the Windows registry. This class is a registry encapsulation.</summary>
+	// Token: 0x02000066 RID: 102
+	[Token(Token = "0x2000066")]
+	[ComVisible(true)]
+	public sealed class RegistryKey : MarshalByRefObject, IDisposable
+	{
+		// Token: 0x06000295 RID: 661 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000295")]
+		[Address(RVA = "0x2AB4860", Offset = "0x2AB3660", VA = "0x182AB4860")]
+		internal RegistryKey(RegistryHive hiveId)
+		{
+		}
+
+		// Token: 0x06000296 RID: 662 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000296")]
+		[Address(RVA = "0x2AB46A0", Offset = "0x2AB34A0", VA = "0x182AB46A0")]
+		internal RegistryKey(RegistryHive hiveId, IntPtr keyHandle, bool remoteRoot)
+		{
+		}
+
+		// Token: 0x06000297 RID: 663 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000297")]
+		[Address(RVA = "0x2AB4650", Offset = "0x2AB3450", VA = "0x182AB4650")]
+		internal RegistryKey(object data, string keyName, bool writable)
+		{
+		}
+
+		// Token: 0x06000298 RID: 664 RVA: 0x000031C8 File Offset: 0x000013C8
+		[Token(Token = "0x6000298")]
+		[Address(RVA = "0x2AB3E30", Offset = "0x2AB2C30", VA = "0x182AB3E30")]
+		internal static bool IsEquals(RegistryKey a, RegistryKey b)
+		{
+			return default(bool);
+		}
+
+		/// <summary>Releases all resources used by the current instance of the <see cref="T:Microsoft.Win32.RegistryKey" /> class.</summary>
+		// Token: 0x06000299 RID: 665 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000299")]
+		[Address(RVA = "0x2AB36F0", Offset = "0x2AB24F0", VA = "0x182AB36F0", Slot = "6")]
+		public void Dispose()
+		{
+		}
+
+		/// <summary>Retrieves the name of the key.</summary>
+		/// <returns>The absolute (qualified) name of the key.</returns>
+		/// <exception cref="T:System.ObjectDisposedException">The <see cref="T:Microsoft.Win32.RegistryKey" /> is closed (closed keys cannot be accessed).</exception>
+		// Token: 0x1700005E RID: 94
+		// (get) Token: 0x0600029A RID: 666 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x1700005E")]
+		public string Name
+		{
+			[Token(Token = "0x600029A")]
+			[Address(RVA = "0x3FA180", Offset = "0x3F8F80", VA = "0x1803FA180")]
+			get
+			{
+				return null;
+			}
+		}
+
+		/// <summary>Writes all the attributes of the specified open registry key into the registry.</summary>
+		// Token: 0x0600029B RID: 667 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600029B")]
+		[Address(RVA = "0x2AB3830", Offset = "0x2AB2630", VA = "0x182AB3830")]
+		public void Flush()
+		{
+		}
+
+		/// <summary>Closes the key and flushes it to disk if its contents have been modified.</summary>
+		// Token: 0x0600029C RID: 668 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600029C")]
+		[Address(RVA = "0x2AB32B0", Offset = "0x2AB20B0", VA = "0x182AB32B0")]
+		public void Close()
+		{
+		}
+
+		/// <summary>Gets a <see cref="T:Microsoft.Win32.SafeHandles.SafeRegistryHandle" /> object that represents the registry key that the current <see cref="T:Microsoft.Win32.RegistryKey" /> object encapsulates.</summary>
+		/// <returns>The handle to the registry key.</returns>
+		/// <exception cref="T:System.ObjectDisposedException">The registry key is closed. Closed keys cannot be accessed.</exception>
+		/// <exception cref="T:System.UnauthorizedAccessException">The user does not have the necessary registry rights.</exception>
+		/// <exception cref="T:System.IO.IOException">A system error occurred, such as deletion of the current key.</exception>
+		/// <exception cref="T:System.Security.SecurityException">The user does not have the permissions required to read the key.</exception>
+		// Token: 0x1700005F RID: 95
+		// (get) Token: 0x0600029D RID: 669 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x1700005F")]
+		[MonoTODO]
+		[MonoTODO("Not implemented in Unix")]
+		[ComVisible(false)]
+		public SafeRegistryHandle Handle
+		{
+			[Token(Token = "0x600029D")]
+			[Address(RVA = "0x2AB4A30", Offset = "0x2AB3830", VA = "0x182AB4A30")]
+			get
+			{
+				return null;
+			}
+		}
+
+		/// <summary>Sets the specified name/value pair.</summary>
+		/// <param name="name">The name of the value to store.</param>
+		/// <param name="value">The data to be stored.</param>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="value" /> is <see langword="null" />.</exception>
+		/// <exception cref="T:System.ArgumentException">
+		///   <paramref name="value" /> is an unsupported data type.</exception>
+		/// <exception cref="T:System.ObjectDisposedException">The <see cref="T:Microsoft.Win32.RegistryKey" /> that contains the specified value is closed (closed keys cannot be accessed).</exception>
+		/// <exception cref="T:System.UnauthorizedAccessException">The <see cref="T:Microsoft.Win32.RegistryKey" /> is read-only, and cannot be written to; for example, the key has not been opened with write access.  
+		///  -or-  
+		///  The <see cref="T:Microsoft.Win32.RegistryKey" /> object represents a root-level node, and the operating system is Windows Millennium Edition or Windows 98.</exception>
+		/// <exception cref="T:System.Security.SecurityException">The user does not have the permissions required to create or modify registry keys.</exception>
+		/// <exception cref="T:System.IO.IOException">The <see cref="T:Microsoft.Win32.RegistryKey" /> object represents a root-level node, and the operating system is Windows 2000, Windows XP, or Windows Server 2003.</exception>
+		// Token: 0x0600029E RID: 670 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600029E")]
+		[Address(RVA = "0x2AB4200", Offset = "0x2AB3000", VA = "0x182AB4200")]
+		public void SetValue(string name, object value)
+		{
+		}
+
+		/// <summary>Retrieves a subkey as read-only.</summary>
+		/// <param name="name">The name or path of the subkey to open as read-only.</param>
+		/// <returns>The subkey requested, or <see langword="null" /> if the operation failed.</returns>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="name" /> is <see langword="null" /></exception>
+		/// <exception cref="T:System.ObjectDisposedException">The <see cref="T:Microsoft.Win32.RegistryKey" /> is closed (closed keys cannot be accessed).</exception>
+		/// <exception cref="T:System.Security.SecurityException">The user does not have the permissions required to read the registry key.</exception>
+		// Token: 0x0600029F RID: 671 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x600029F")]
+		[Address(RVA = "0x2AB3EB0", Offset = "0x2AB2CB0", VA = "0x182AB3EB0")]
+		public RegistryKey OpenSubKey(string name)
+		{
+			return null;
+		}
+
+		/// <summary>Retrieves a specified subkey, and specifies whether write access is to be applied to the key.</summary>
+		/// <param name="name">Name or path of the subkey to open.</param>
+		/// <param name="writable">Set to <see langword="true" /> if you need write access to the key.</param>
+		/// <returns>The subkey requested, or <see langword="null" /> if the operation failed.</returns>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="name" /> is <see langword="null" />.</exception>
+		/// <exception cref="T:System.ObjectDisposedException">The <see cref="T:Microsoft.Win32.RegistryKey" /> is closed (closed keys cannot be accessed).</exception>
+		/// <exception cref="T:System.Security.SecurityException">The user does not have the permissions required to access the registry key in the specified mode.</exception>
+		// Token: 0x060002A0 RID: 672 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60002A0")]
+		[Address(RVA = "0x2AB4050", Offset = "0x2AB2E50", VA = "0x182AB4050")]
+		public RegistryKey OpenSubKey(string name, bool writable)
+		{
+			return null;
+		}
+
+		/// <summary>Retrieves the value associated with the specified name. Returns <see langword="null" /> if the name/value pair does not exist in the registry.</summary>
+		/// <param name="name">The name of the value to retrieve. This string is not case-sensitive.</param>
+		/// <returns>The value associated with <paramref name="name" />, or <see langword="null" /> if <paramref name="name" /> is not found.</returns>
+		/// <exception cref="T:System.Security.SecurityException">The user does not have the permissions required to read from the registry key.</exception>
+		/// <exception cref="T:System.ObjectDisposedException">The <see cref="T:Microsoft.Win32.RegistryKey" /> that contains the specified value is closed (closed keys cannot be accessed).</exception>
+		/// <exception cref="T:System.IO.IOException">The <see cref="T:Microsoft.Win32.RegistryKey" /> that contains the specified value has been marked for deletion.</exception>
+		/// <exception cref="T:System.UnauthorizedAccessException">The user does not have the necessary registry rights.</exception>
+		// Token: 0x060002A1 RID: 673 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60002A1")]
+		[Address(RVA = "0x2AB3CC0", Offset = "0x2AB2AC0", VA = "0x182AB3CC0")]
+		public object GetValue(string name)
+		{
+			return null;
+		}
+
+		/// <summary>Retrieves the value associated with the specified name. If the name is not found, returns the default value that you provide.</summary>
+		/// <param name="name">The name of the value to retrieve. This string is not case-sensitive.</param>
+		/// <param name="defaultValue">The value to return if <paramref name="name" /> does not exist.</param>
+		/// <returns>The value associated with <paramref name="name" />, with any embedded environment variables left unexpanded, or <paramref name="defaultValue" /> if <paramref name="name" /> is not found.</returns>
+		/// <exception cref="T:System.Security.SecurityException">The user does not have the permissions required to read from the registry key.</exception>
+		/// <exception cref="T:System.ObjectDisposedException">The <see cref="T:Microsoft.Win32.RegistryKey" /> that contains the specified value is closed (closed keys cannot be accessed).</exception>
+		/// <exception cref="T:System.IO.IOException">The <see cref="T:Microsoft.Win32.RegistryKey" /> that contains the specified value has been marked for deletion.</exception>
+		/// <exception cref="T:System.UnauthorizedAccessException">The user does not have the necessary registry rights.</exception>
+		// Token: 0x060002A2 RID: 674 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60002A2")]
+		[Address(RVA = "0x2AB3B40", Offset = "0x2AB2940", VA = "0x182AB3B40")]
+		public object GetValue(string name, object defaultValue)
+		{
+			return null;
+		}
+
+		/// <summary>Creates a new subkey or opens an existing subkey for write access.</summary>
+		/// <param name="subkey">The name or path of the subkey to create or open. This string is not case-sensitive.</param>
+		/// <returns>The newly created subkey, or <see langword="null" /> if the operation failed. If a zero-length string is specified for <paramref name="subkey" />, the current <see cref="T:Microsoft.Win32.RegistryKey" /> object is returned.</returns>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="subkey" /> is <see langword="null" />.</exception>
+		/// <exception cref="T:System.Security.SecurityException">The user does not have the permissions required to create or open the registry key.</exception>
+		/// <exception cref="T:System.ObjectDisposedException">The <see cref="T:Microsoft.Win32.RegistryKey" /> on which this method is being invoked is closed (closed keys cannot be accessed).</exception>
+		/// <exception cref="T:System.UnauthorizedAccessException">The <see cref="T:Microsoft.Win32.RegistryKey" /> cannot be written to; for example, it was not opened as a writable key , or the user does not have the necessary access rights.</exception>
+		/// <exception cref="T:System.IO.IOException">The nesting level exceeds 510.  
+		///  -or-  
+		///  A system error occurred, such as deletion of the key, or an attempt to create a key in the <see cref="F:Microsoft.Win32.Registry.LocalMachine" /> root.</exception>
+		// Token: 0x060002A3 RID: 675 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60002A3")]
+		[Address(RVA = "0x2AB3410", Offset = "0x2AB2210", VA = "0x182AB3410")]
+		public RegistryKey CreateSubKey(string subkey)
+		{
+			return null;
+		}
+
+		/// <summary>Retrieves an array of strings that contains all the subkey names.</summary>
+		/// <returns>An array of strings that contains the names of the subkeys for the current key.</returns>
+		/// <exception cref="T:System.Security.SecurityException">The user does not have the permissions required to read from the key.</exception>
+		/// <exception cref="T:System.ObjectDisposedException">The <see cref="T:Microsoft.Win32.RegistryKey" /> being manipulated is closed (closed keys cannot be accessed).</exception>
+		/// <exception cref="T:System.UnauthorizedAccessException">The user does not have the necessary registry rights.</exception>
+		/// <exception cref="T:System.IO.IOException">A system error occurred, for example the current key has been deleted.</exception>
+		// Token: 0x060002A4 RID: 676 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60002A4")]
+		[Address(RVA = "0x2AB3A00", Offset = "0x2AB2800", VA = "0x182AB3A00")]
+		public string[] GetSubKeyNames()
+		{
+			return null;
+		}
+
+		/// <summary>Retrieves a string representation of this key.</summary>
+		/// <returns>A string representing the key. If the specified key is invalid (cannot be found) then <see langword="null" /> is returned.</returns>
+		/// <exception cref="T:System.ObjectDisposedException">The <see cref="T:Microsoft.Win32.RegistryKey" /> being accessed is closed (closed keys cannot be accessed).</exception>
+		// Token: 0x060002A5 RID: 677 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60002A5")]
+		[Address(RVA = "0x2AB43F0", Offset = "0x2AB31F0", VA = "0x182AB43F0", Slot = "3")]
+		public override string ToString()
+		{
+			return null;
+		}
+
+		// Token: 0x17000060 RID: 96
+		// (get) Token: 0x060002A6 RID: 678 RVA: 0x000031E0 File Offset: 0x000013E0
+		[Token(Token = "0x17000060")]
+		internal bool IsRoot
+		{
+			[Token(Token = "0x60002A6")]
+			[Address(RVA = "0x58C2E0", Offset = "0x58B0E0", VA = "0x18058C2E0")]
+			get
+			{
+				return default(bool);
+			}
+		}
+
+		// Token: 0x17000061 RID: 97
+		// (get) Token: 0x060002A7 RID: 679 RVA: 0x000031F8 File Offset: 0x000013F8
+		[Token(Token = "0x17000061")]
+		private bool IsWritable
+		{
+			[Token(Token = "0x60002A7")]
+			[Address(RVA = "0x43AAA0", Offset = "0x4398A0", VA = "0x18043AAA0")]
+			get
+			{
+				return default(bool);
+			}
+		}
+
+		// Token: 0x17000062 RID: 98
+		// (get) Token: 0x060002A8 RID: 680 RVA: 0x00003210 File Offset: 0x00001410
+		[Token(Token = "0x17000062")]
+		internal RegistryHive Hive
+		{
+			[Token(Token = "0x60002A8")]
+			[Address(RVA = "0x2AB4BD0", Offset = "0x2AB39D0", VA = "0x182AB4BD0")]
+			get
+			{
+				return (RegistryHive)0;
+			}
+		}
+
+		// Token: 0x17000063 RID: 99
+		// (get) Token: 0x060002A9 RID: 681 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x17000063")]
+		internal object InternalHandle
+		{
+			[Token(Token = "0x60002A9")]
+			[Address(RVA = "0x3F5F40", Offset = "0x3F4D40", VA = "0x1803F5F40")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x060002AA RID: 682 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60002AA")]
+		[Address(RVA = "0x2AB3240", Offset = "0x2AB2040", VA = "0x182AB3240")]
+		private void AssertKeyStillValid()
+		{
+		}
+
+		// Token: 0x060002AB RID: 683 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60002AB")]
+		[Address(RVA = "0x2AB31E0", Offset = "0x2AB1FE0", VA = "0x182AB31E0")]
+		private void AssertKeyNameNotNull(string subKeyName)
+		{
+		}
+
+		// Token: 0x060002AC RID: 684 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60002AC")]
+		[Address(RVA = "0x2AB3170", Offset = "0x2AB1F70", VA = "0x182AB3170")]
+		private void AssertKeyNameLength(string name)
+		{
+		}
+
+		// Token: 0x060002AD RID: 685 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60002AD")]
+		[Address(RVA = "0x2AB3650", Offset = "0x2AB2450", VA = "0x182AB3650")]
+		internal static string DecodeString(byte[] data)
+		{
+			return null;
+		}
+
+		// Token: 0x060002AE RID: 686 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60002AE")]
+		[Address(RVA = "0x2AB33B0", Offset = "0x2AB21B0", VA = "0x182AB33B0")]
+		internal static IOException CreateMarkedForDeletionException()
+		{
+			return null;
+		}
+
+		// Token: 0x060002AF RID: 687 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60002AF")]
+		[Address(RVA = "0x2AB38B0", Offset = "0x2AB26B0", VA = "0x182AB38B0")]
+		private static string GetHiveName(RegistryHive hive)
+		{
+			return null;
+		}
+
+		// Token: 0x04000190 RID: 400
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x18")]
+		[Token(Token = "0x4000190")]
+		private object handle;
+
+		// Token: 0x04000191 RID: 401
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x20")]
+		[Token(Token = "0x4000191")]
+		private SafeRegistryHandle safe_handle;
+
+		// Token: 0x04000192 RID: 402
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x28")]
+		[Token(Token = "0x4000192")]
+		private object hive;
+
+		// Token: 0x04000193 RID: 403
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x30")]
+		[Token(Token = "0x4000193")]
+		private readonly string qname;
+
+		// Token: 0x04000194 RID: 404
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x38")]
+		[Token(Token = "0x4000194")]
+		private readonly bool isRemoteRoot;
+
+		// Token: 0x04000195 RID: 405
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x39")]
+		[Token(Token = "0x4000195")]
+		private readonly bool isWritable;
+
+		// Token: 0x04000196 RID: 406
+		[Token(Token = "0x4000196")]
+		private static readonly IRegistryApi RegistryApi;
+	}
+}

mscorlib/Microsoft/Win32/RegistryKeyComparer.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Collections;
+using Cpp2IlInjected;
+
+namespace Microsoft.Win32
+{
+	// Token: 0x0200006A RID: 106
+	[Token(Token = "0x200006A")]
+	internal class RegistryKeyComparer : IEqualityComparer
+	{
+		// Token: 0x060002B3 RID: 691 RVA: 0x00003228 File Offset: 0x00001428
+		[Token(Token = "0x60002B3")]
+		[Address(RVA = "0x2AB2FF0", Offset = "0x2AB1DF0", VA = "0x182AB2FF0", Slot = "4")]
+		public bool Equals(object x, object y)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x060002B4 RID: 692 RVA: 0x00003240 File Offset: 0x00001440
+		[Token(Token = "0x60002B4")]
+		[Address(RVA = "0x2AB30F0", Offset = "0x2AB1EF0", VA = "0x182AB30F0", Slot = "5")]
+		public int GetHashCode(object obj)
+		{
+			return 0;
+		}
+
+		// Token: 0x060002B5 RID: 693 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60002B5")]
+		[Address(RVA = "0x3F5100", Offset = "0x3F3F00", VA = "0x1803F5100")]
+		public RegistryKeyComparer()
+		{
+		}
+	}
+}

mscorlib/Microsoft/Win32/RegistryValueKind.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Runtime.InteropServices;
+using Cpp2IlInjected;
+
+namespace Microsoft.Win32
+{
+	/// <summary>Specifies the data types to use when storing values in the registry, or identifies the data type of a value in the registry.</summary>
+	// Token: 0x02000067 RID: 103
+	[Token(Token = "0x2000067")]
+	[ComVisible(true)]
+	public enum RegistryValueKind
+	{
+		/// <summary>An unsupported registry data type. For example, the Microsoft Win32 API registry data type REG_RESOURCE_LIST is unsupported. Use this value to specify that the <see cref="M:Microsoft.Win32.RegistryKey.SetValue(System.String,System.Object)" /> method should determine the appropriate registry data type when storing a name/value pair.</summary>
+		// Token: 0x04000198 RID: 408
+		[Token(Token = "0x4000198")]
+		Unknown,
+		/// <summary>A null-terminated string. This value is equivalent to the Win32 API registry data type REG_SZ.</summary>
+		// Token: 0x04000199 RID: 409
+		[Token(Token = "0x4000199")]
+		String,
+		/// <summary>A null-terminated string that contains unexpanded references to environment variables, such as %PATH%, that are expanded when the value is retrieved. This value is equivalent to the Win32 API registry data type REG_EXPAND_SZ.</summary>
+		// Token: 0x0400019A RID: 410
+		[Token(Token = "0x400019A")]
+		ExpandString,
+		/// <summary>Binary data in any form. This value is equivalent to the Win32 API registry data type REG_BINARY.</summary>
+		// Token: 0x0400019B RID: 411
+		[Token(Token = "0x400019B")]
+		Binary,
+		/// <summary>A 32-bit binary number. This value is equivalent to the Win32 API registry data type REG_DWORD.</summary>
+		// Token: 0x0400019C RID: 412
+		[Token(Token = "0x400019C")]
+		DWord,
+		/// <summary>An array of null-terminated strings, terminated by two null characters. This value is equivalent to the Win32 API registry data type REG_MULTI_SZ.</summary>
+		// Token: 0x0400019D RID: 413
+		[Token(Token = "0x400019D")]
+		MultiString = 7,
+		/// <summary>A 64-bit binary number. This value is equivalent to the Win32 API registry data type REG_QWORD.</summary>
+		// Token: 0x0400019E RID: 414
+		[Token(Token = "0x400019E")]
+		QWord = 11,
+		/// <summary>No data type.</summary>
+		// Token: 0x0400019F RID: 415
+		[Token(Token = "0x400019F")]
+		None = -1
+	}
+}

mscorlib/Microsoft/Win32/RegistryValueOptions.cs

@@ -0,0 +1,21 @@
+using System;
+using Cpp2IlInjected;
+
+namespace Microsoft.Win32
+{
+	/// <summary>Specifies optional behavior when retrieving name/value pairs from a registry key.</summary>
+	// Token: 0x02000068 RID: 104
+	[Token(Token = "0x2000068")]
+	[Flags]
+	public enum RegistryValueOptions
+	{
+		/// <summary>No optional behavior is specified.</summary>
+		// Token: 0x040001A1 RID: 417
+		[Token(Token = "0x40001A1")]
+		None = 0,
+		/// <summary>A value of type <see cref="F:Microsoft.Win32.RegistryValueKind.ExpandString" /> is retrieved without expanding its embedded environment variables.</summary>
+		// Token: 0x040001A2 RID: 418
+		[Token(Token = "0x40001A2")]
+		DoNotExpandEnvironmentNames = 1
+	}
+}

mscorlib/Microsoft/Win32/SafeHandles/SafeFileHandle.cs

@@ -0,0 +1,30 @@
+using System;
+using Cpp2IlInjected;
+
+namespace Microsoft.Win32.SafeHandles
+{
+	/// <summary>Represents a wrapper class for a file handle.</summary>
+	// Token: 0x02000070 RID: 112
+	[Token(Token = "0x2000070")]
+	public sealed class SafeFileHandle : SafeHandleZeroOrMinusOneIsInvalid
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:Microsoft.Win32.SafeHandles.SafeFileHandle" /> class.</summary>
+		/// <param name="preexistingHandle">An <see cref="T:System.IntPtr" /> object that represents the pre-existing handle to use.</param>
+		/// <param name="ownsHandle">
+		///   <see langword="true" /> to reliably release the handle during the finalization phase; <see langword="false" /> to prevent reliable release (not recommended).</param>
+		// Token: 0x06000302 RID: 770 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000302")]
+		[Address(RVA = "0x2AB5380", Offset = "0x2AB4180", VA = "0x182AB5380")]
+		public SafeFileHandle(IntPtr preexistingHandle, bool ownsHandle)
+		{
+		}
+
+		// Token: 0x06000303 RID: 771 RVA: 0x00003378 File Offset: 0x00001578
+		[Token(Token = "0x6000303")]
+		[Address(RVA = "0x2AB5310", Offset = "0x2AB4110", VA = "0x182AB5310", Slot = "7")]
+		protected override bool ReleaseHandle()
+		{
+			return default(bool);
+		}
+	}
+}

mscorlib/Microsoft/Win32/SafeHandles/SafeFindHandle.cs

@@ -0,0 +1,25 @@
+using System;
+using Cpp2IlInjected;
+
+namespace Microsoft.Win32.SafeHandles
+{
+	// Token: 0x02000071 RID: 113
+	[Token(Token = "0x2000071")]
+	internal sealed class SafeFindHandle : SafeHandleZeroOrMinusOneIsInvalid
+	{
+		// Token: 0x06000304 RID: 772 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000304")]
+		[Address(RVA = "0x2AB5440", Offset = "0x2AB4240", VA = "0x182AB5440")]
+		internal SafeFindHandle(IntPtr preexistingHandle)
+		{
+		}
+
+		// Token: 0x06000305 RID: 773 RVA: 0x00003390 File Offset: 0x00001590
+		[Token(Token = "0x6000305")]
+		[Address(RVA = "0x2AB53E0", Offset = "0x2AB41E0", VA = "0x182AB53E0", Slot = "7")]
+		protected override bool ReleaseHandle()
+		{
+			return default(bool);
+		}
+	}
+}

mscorlib/Microsoft/Win32/SafeHandles/SafeHandleZeroOrMinusOneIsInvalid.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Runtime.ConstrainedExecution;
+using System.Runtime.InteropServices;
+using Cpp2IlInjected;
+
+namespace Microsoft.Win32.SafeHandles
+{
+	/// <summary>Provides a base class for Win32 safe handle implementations in which the value of either 0 or -1 indicates an invalid handle.</summary>
+	// Token: 0x02000074 RID: 116
+	[Token(Token = "0x2000074")]
+	public abstract class SafeHandleZeroOrMinusOneIsInvalid : SafeHandle
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:Microsoft.Win32.SafeHandles.SafeHandleZeroOrMinusOneIsInvalid" /> class, specifying whether the handle is to be reliably released.</summary>
+		/// <param name="ownsHandle">
+		///   <see langword="true" /> to reliably release the handle during the finalization phase; <see langword="false" /> to prevent reliable release (not recommended).</param>
+		// Token: 0x0600030A RID: 778 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600030A")]
+		[Address(RVA = "0x2AB5490", Offset = "0x2AB4290", VA = "0x182AB5490")]
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
+		protected SafeHandleZeroOrMinusOneIsInvalid(bool ownsHandle)
+		{
+		}
+
+		/// <summary>Gets a value that indicates whether the handle is invalid.</summary>
+		/// <returns>
+		///   <see langword="true" /> if the handle is not valid; otherwise, <see langword="false" />.</returns>
+		// Token: 0x17000067 RID: 103
+		// (get) Token: 0x0600030B RID: 779 RVA: 0x000033D8 File Offset: 0x000015D8
+		[Token(Token = "0x17000067")]
+		public override bool IsInvalid
+		{
+			[Token(Token = "0x600030B")]
+			[Address(RVA = "0x2AB54E0", Offset = "0x2AB42E0", VA = "0x182AB54E0", Slot = "5")]
+			get
+			{
+				return default(bool);
+			}
+		}
+	}
+}

mscorlib/Microsoft/Win32/SafeHandles/SafeRegistryHandle.cs

@@ -0,0 +1,30 @@
+using System;
+using Cpp2IlInjected;
+
+namespace Microsoft.Win32.SafeHandles
+{
+	/// <summary>Represents a safe handle to the Windows registry.</summary>
+	// Token: 0x02000072 RID: 114
+	[Token(Token = "0x2000072")]
+	public sealed class SafeRegistryHandle : SafeHandleZeroOrMinusOneIsInvalid
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:Microsoft.Win32.SafeHandles.SafeRegistryHandle" /> class.</summary>
+		/// <param name="preexistingHandle">An object that represents the pre-existing handle to use.</param>
+		/// <param name="ownsHandle">
+		///   <see langword="true" /> to reliably release the handle during the finalization phase; <see langword="false" /> to prevent reliable release.</param>
+		// Token: 0x06000306 RID: 774 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000306")]
+		[Address(RVA = "0x2AB5380", Offset = "0x2AB4180", VA = "0x182AB5380")]
+		public SafeRegistryHandle(IntPtr preexistingHandle, bool ownsHandle)
+		{
+		}
+
+		// Token: 0x06000307 RID: 775 RVA: 0x000033A8 File Offset: 0x000015A8
+		[Token(Token = "0x6000307")]
+		[Address(RVA = "0x460D40", Offset = "0x45FB40", VA = "0x180460D40", Slot = "7")]
+		protected override bool ReleaseHandle()
+		{
+			return default(bool);
+		}
+	}
+}

mscorlib/Microsoft/Win32/SafeHandles/SafeWaitHandle.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Runtime.ConstrainedExecution;
+using Cpp2IlInjected;
+
+namespace Microsoft.Win32.SafeHandles
+{
+	/// <summary>Represents a wrapper class for a wait handle.</summary>
+	// Token: 0x02000073 RID: 115
+	[Token(Token = "0x2000073")]
+	public sealed class SafeWaitHandle : SafeHandleZeroOrMinusOneIsInvalid
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:Microsoft.Win32.SafeHandles.SafeWaitHandle" /> class.</summary>
+		/// <param name="existingHandle">An <see cref="T:System.IntPtr" /> object that represents the pre-existing handle to use.</param>
+		/// <param name="ownsHandle">
+		///   <see langword="true" /> to reliably release the handle during the finalization phase; <see langword="false" /> to prevent reliable release (not recommended).</param>
+		// Token: 0x06000308 RID: 776 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000308")]
+		[Address(RVA = "0x2AB5380", Offset = "0x2AB4180", VA = "0x182AB5380")]
+		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
+		public SafeWaitHandle(IntPtr existingHandle, bool ownsHandle)
+		{
+		}
+
+		// Token: 0x06000309 RID: 777 RVA: 0x000033C0 File Offset: 0x000015C0
+		[Token(Token = "0x6000309")]
+		[Address(RVA = "0x2AB5540", Offset = "0x2AB4340", VA = "0x182AB5540", Slot = "7")]
+		protected override bool ReleaseHandle()
+		{
+			return default(bool);
+		}
+	}
+}

mscorlib/Microsoft/Win32/UnixRegistryApi.cs

@@ -0,0 +1,118 @@
+using System;
+using Cpp2IlInjected;
+
+namespace Microsoft.Win32
+{
+	// Token: 0x0200006C RID: 108
+	[Token(Token = "0x200006C")]
+	internal class UnixRegistryApi : IRegistryApi
+	{
+		// Token: 0x060002D4 RID: 724 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60002D4")]
+		[Address(RVA = "0x2ABD310", Offset = "0x2ABC110", VA = "0x182ABD310")]
+		private static string ToUnix(string keyname)
+		{
+			return null;
+		}
+
+		// Token: 0x060002D5 RID: 725 RVA: 0x000032D0 File Offset: 0x000014D0
+		[Token(Token = "0x60002D5")]
+		[Address(RVA = "0x2ABCEF0", Offset = "0x2ABBCF0", VA = "0x182ABCEF0")]
+		private static bool IsWellKnownKey(string parentKeyName, string keyname)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x060002D6 RID: 726 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60002D6")]
+		[Address(RVA = "0x2ABCB60", Offset = "0x2ABB960", VA = "0x182ABCB60", Slot = "4")]
+		public RegistryKey CreateSubKey(RegistryKey rkey, string keyname)
+		{
+			return null;
+		}
+
+		// Token: 0x060002D7 RID: 727 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60002D7")]
+		[Address(RVA = "0x2ABD020", Offset = "0x2ABBE20", VA = "0x182ABD020", Slot = "5")]
+		public RegistryKey OpenSubKey(RegistryKey rkey, string keyname, bool writable)
+		{
+			return null;
+		}
+
+		// Token: 0x060002D8 RID: 728 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60002D8")]
+		[Address(RVA = "0x2ABCD10", Offset = "0x2ABBB10", VA = "0x182ABCD10", Slot = "6")]
+		public void Flush(RegistryKey rkey)
+		{
+		}
+
+		// Token: 0x060002D9 RID: 729 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60002D9")]
+		[Address(RVA = "0x2ABC960", Offset = "0x2ABB760", VA = "0x182ABC960", Slot = "7")]
+		public void Close(RegistryKey rkey)
+		{
+		}
+
+		// Token: 0x060002DA RID: 730 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60002DA")]
+		[Address(RVA = "0x2ABCE40", Offset = "0x2ABBC40", VA = "0x182ABCE40", Slot = "8")]
+		public object GetValue(RegistryKey rkey, string name, object default_value, RegistryValueOptions options)
+		{
+			return null;
+		}
+
+		// Token: 0x060002DB RID: 731 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60002DB")]
+		[Address(RVA = "0x2ABD260", Offset = "0x2ABC060", VA = "0x182ABD260", Slot = "9")]
+		public void SetValue(RegistryKey rkey, string name, object value)
+		{
+		}
+
+		// Token: 0x060002DC RID: 732 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60002DC")]
+		[Address(RVA = "0x2ABCDD0", Offset = "0x2ABBBD0", VA = "0x182ABCDD0", Slot = "10")]
+		public string[] GetSubKeyNames(RegistryKey rkey)
+		{
+			return null;
+		}
+
+		// Token: 0x060002DD RID: 733 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60002DD")]
+		[Address(RVA = "0x901BC0", Offset = "0x9009C0", VA = "0x180901BC0", Slot = "11")]
+		public string ToString(RegistryKey rkey)
+		{
+			return null;
+		}
+
+		// Token: 0x060002DE RID: 734 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60002DE")]
+		[Address(RVA = "0x2ABCB80", Offset = "0x2ABB980", VA = "0x182ABCB80")]
+		private RegistryKey CreateSubKey(RegistryKey rkey, string keyname, bool writable)
+		{
+			return null;
+		}
+
+		// Token: 0x060002DF RID: 735 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60002DF")]
+		[Address(RVA = "0x2ABC9C0", Offset = "0x2ABB7C0", VA = "0x182ABC9C0")]
+		private RegistryKey CreateSubKey(RegistryKey rkey, string keyname, bool writable, bool is_volatile)
+		{
+			return null;
+		}
+
+		// Token: 0x060002E0 RID: 736 RVA: 0x000032E8 File Offset: 0x000014E8
+		[Token(Token = "0x60002E0")]
+		[Address(RVA = "0x2ABCD80", Offset = "0x2ABBB80", VA = "0x182ABCD80", Slot = "12")]
+		public IntPtr GetHandle(RegistryKey key)
+		{
+			return 0;
+		}
+
+		// Token: 0x060002E1 RID: 737 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60002E1")]
+		[Address(RVA = "0x3F5100", Offset = "0x3F3F00", VA = "0x1803F5100")]
+		public UnixRegistryApi()
+		{
+		}
+	}
+}

mscorlib/Microsoft/Win32/UnsafeNativeMethods.cs

@@ -0,0 +1,222 @@
+using System;
+using System.Diagnostics.Tracing;
+using System.Runtime.InteropServices;
+using Cpp2IlInjected;
+
+namespace Microsoft.Win32
+{
+	// Token: 0x02000059 RID: 89
+	[Token(Token = "0x2000059")]
+	internal static class UnsafeNativeMethods
+	{
+		// Token: 0x0200005A RID: 90
+		[Token(Token = "0x200005A")]
+		internal static class ManifestEtw
+		{
+			// Token: 0x0600027F RID: 639
+			[Token(Token = "0x600027F")]
+			[Address(RVA = "0x2AB1220", Offset = "0x2AB0020", VA = "0x182AB1220")]
+			internal unsafe static extern uint EventRegister([In] ref Guid providerId, [In] UnsafeNativeMethods.ManifestEtw.EtwEnableCallback enableCallback, [In] void* callbackContext, [In] [Out] ref long registrationHandle);
+
+			// Token: 0x06000280 RID: 640
+			[Token(Token = "0x6000280")]
+			[Address(RVA = "0x2AB1370", Offset = "0x2AB0170", VA = "0x182AB1370")]
+			internal static extern uint EventUnregister([In] long registrationHandle);
+
+			// Token: 0x06000281 RID: 641 RVA: 0x000031B0 File Offset: 0x000013B0
+			[Token(Token = "0x6000281")]
+			[Address(RVA = "0x2AB13F0", Offset = "0x2AB01F0", VA = "0x182AB13F0")]
+			internal unsafe static int EventWriteTransferWrapper(long registrationHandle, ref EventDescriptor eventDescriptor, Guid* activityId, Guid* relatedActivityId, int userDataCount, EventProvider.EventData* userData)
+			{
+				return 0;
+			}
+
+			// Token: 0x06000282 RID: 642
+			[Token(Token = "0x6000282")]
+			[Address(RVA = "0x2AB14F0", Offset = "0x2AB02F0", VA = "0x182AB14F0")]
+			private unsafe static extern int EventWriteTransfer([In] long registrationHandle, [In] ref EventDescriptor eventDescriptor, [In] Guid* activityId, [In] Guid* relatedActivityId, [In] int userDataCount, [In] EventProvider.EventData* userData);
+
+			// Token: 0x06000283 RID: 643
+			[Token(Token = "0x6000283")]
+			[Address(RVA = "0x2AB1190", Offset = "0x2AAFF90", VA = "0x182AB1190")]
+			internal static extern int EventActivityIdControl([In] UnsafeNativeMethods.ManifestEtw.ActivityControl ControlCode, [In] [Out] ref Guid ActivityId);
+
+			// Token: 0x06000284 RID: 644
+			[Token(Token = "0x6000284")]
+			[Address(RVA = "0x2AB12D0", Offset = "0x2AB00D0", VA = "0x182AB12D0")]
+			internal unsafe static extern int EventSetInformation([In] long registrationHandle, [In] UnsafeNativeMethods.ManifestEtw.EVENT_INFO_CLASS informationClass, [In] void* eventInformation, [In] int informationLength);
+
+			// Token: 0x06000285 RID: 645
+			[Token(Token = "0x6000285")]
+			[Address(RVA = "0x2AB10D0", Offset = "0x2AAFED0", VA = "0x182AB10D0")]
+			internal unsafe static extern int EnumerateTraceGuidsEx(UnsafeNativeMethods.ManifestEtw.TRACE_QUERY_INFO_CLASS TraceQueryInfoClass, void* InBuffer, int InBufferSize, void* OutBuffer, int OutBufferSize, ref int ReturnLength);
+
+			// Token: 0x0200005B RID: 91
+			// (Invoke) Token: 0x06000287 RID: 647
+			[Token(Token = "0x200005B")]
+			internal unsafe delegate void EtwEnableCallback([In] ref Guid sourceId, [In] int isEnabled, [In] byte level, [In] long matchAnyKeywords, [In] long matchAllKeywords, [In] UnsafeNativeMethods.ManifestEtw.EVENT_FILTER_DESCRIPTOR* filterData, [In] void* callbackContext);
+
+			// Token: 0x0200005C RID: 92
+			[Token(Token = "0x200005C")]
+			internal struct EVENT_FILTER_DESCRIPTOR
+			{
+				// Token: 0x04000160 RID: 352
+				[global::Cpp2IlInjected.FieldOffset(Offset = "0x0")]
+				[Token(Token = "0x4000160")]
+				public long Ptr;
+
+				// Token: 0x04000161 RID: 353
+				[global::Cpp2IlInjected.FieldOffset(Offset = "0x8")]
+				[Token(Token = "0x4000161")]
+				public int Size;
+
+				// Token: 0x04000162 RID: 354
+				[global::Cpp2IlInjected.FieldOffset(Offset = "0xC")]
+				[Token(Token = "0x4000162")]
+				public int Type;
+			}
+
+			// Token: 0x0200005D RID: 93
+			[Token(Token = "0x200005D")]
+			internal enum ActivityControl : uint
+			{
+				// Token: 0x04000164 RID: 356
+				[Token(Token = "0x4000164")]
+				EVENT_ACTIVITY_CTRL_GET_ID = 1U,
+				// Token: 0x04000165 RID: 357
+				[Token(Token = "0x4000165")]
+				EVENT_ACTIVITY_CTRL_SET_ID,
+				// Token: 0x04000166 RID: 358
+				[Token(Token = "0x4000166")]
+				EVENT_ACTIVITY_CTRL_CREATE_ID,
+				// Token: 0x04000167 RID: 359
+				[Token(Token = "0x4000167")]
+				EVENT_ACTIVITY_CTRL_GET_SET_ID,
+				// Token: 0x04000168 RID: 360
+				[Token(Token = "0x4000168")]
+				EVENT_ACTIVITY_CTRL_CREATE_SET_ID
+			}
+
+			// Token: 0x0200005E RID: 94
+			[Token(Token = "0x200005E")]
+			internal enum EVENT_INFO_CLASS
+			{
+				// Token: 0x0400016A RID: 362
+				[Token(Token = "0x400016A")]
+				BinaryTrackInfo,
+				// Token: 0x0400016B RID: 363
+				[Token(Token = "0x400016B")]
+				SetEnableAllKeywords,
+				// Token: 0x0400016C RID: 364
+				[Token(Token = "0x400016C")]
+				SetTraits
+			}
+
+			// Token: 0x0200005F RID: 95
+			[Token(Token = "0x200005F")]
+			internal enum TRACE_QUERY_INFO_CLASS
+			{
+				// Token: 0x0400016E RID: 366
+				[Token(Token = "0x400016E")]
+				TraceGuidQueryList,
+				// Token: 0x0400016F RID: 367
+				[Token(Token = "0x400016F")]
+				TraceGuidQueryInfo,
+				// Token: 0x04000170 RID: 368
+				[Token(Token = "0x4000170")]
+				TraceGuidQueryProcess,
+				// Token: 0x04000171 RID: 369
+				[Token(Token = "0x4000171")]
+				TraceStackTracingInfo,
+				// Token: 0x04000172 RID: 370
+				[Token(Token = "0x4000172")]
+				MaxTraceSetInfoClass
+			}
+
+			// Token: 0x02000060 RID: 96
+			[Token(Token = "0x2000060")]
+			internal struct TRACE_GUID_INFO
+			{
+				// Token: 0x04000173 RID: 371
+				[global::Cpp2IlInjected.FieldOffset(Offset = "0x0")]
+				[Token(Token = "0x4000173")]
+				public int InstanceCount;
+
+				// Token: 0x04000174 RID: 372
+				[global::Cpp2IlInjected.FieldOffset(Offset = "0x4")]
+				[Token(Token = "0x4000174")]
+				public int Reserved;
+			}
+
+			// Token: 0x02000061 RID: 97
+			[Token(Token = "0x2000061")]
+			internal struct TRACE_PROVIDER_INSTANCE_INFO
+			{
+				// Token: 0x04000175 RID: 373
+				[global::Cpp2IlInjected.FieldOffset(Offset = "0x0")]
+				[Token(Token = "0x4000175")]
+				public int NextOffset;
+
+				// Token: 0x04000176 RID: 374
+				[global::Cpp2IlInjected.FieldOffset(Offset = "0x4")]
+				[Token(Token = "0x4000176")]
+				public int EnableCount;
+
+				// Token: 0x04000177 RID: 375
+				[global::Cpp2IlInjected.FieldOffset(Offset = "0x8")]
+				[Token(Token = "0x4000177")]
+				public int Pid;
+
+				// Token: 0x04000178 RID: 376
+				[global::Cpp2IlInjected.FieldOffset(Offset = "0xC")]
+				[Token(Token = "0x4000178")]
+				public int Flags;
+			}
+
+			// Token: 0x02000062 RID: 98
+			[Token(Token = "0x2000062")]
+			internal struct TRACE_ENABLE_INFO
+			{
+				// Token: 0x04000179 RID: 377
+				[global::Cpp2IlInjected.FieldOffset(Offset = "0x0")]
+				[Token(Token = "0x4000179")]
+				public int IsEnabled;
+
+				// Token: 0x0400017A RID: 378
+				[global::Cpp2IlInjected.FieldOffset(Offset = "0x4")]
+				[Token(Token = "0x400017A")]
+				public byte Level;
+
+				// Token: 0x0400017B RID: 379
+				[global::Cpp2IlInjected.FieldOffset(Offset = "0x5")]
+				[Token(Token = "0x400017B")]
+				public byte Reserved1;
+
+				// Token: 0x0400017C RID: 380
+				[global::Cpp2IlInjected.FieldOffset(Offset = "0x6")]
+				[Token(Token = "0x400017C")]
+				public ushort LoggerId;
+
+				// Token: 0x0400017D RID: 381
+				[global::Cpp2IlInjected.FieldOffset(Offset = "0x8")]
+				[Token(Token = "0x400017D")]
+				public int EnableProperty;
+
+				// Token: 0x0400017E RID: 382
+				[global::Cpp2IlInjected.FieldOffset(Offset = "0xC")]
+				[Token(Token = "0x400017E")]
+				public int Reserved2;
+
+				// Token: 0x0400017F RID: 383
+				[global::Cpp2IlInjected.FieldOffset(Offset = "0x10")]
+				[Token(Token = "0x400017F")]
+				public long MatchAnyKeyword;
+
+				// Token: 0x04000180 RID: 384
+				[global::Cpp2IlInjected.FieldOffset(Offset = "0x18")]
+				[Token(Token = "0x4000180")]
+				public long MatchAllKeyword;
+			}
+		}
+	}
+}

mscorlib/Microsoft/Win32/Win32Native.cs

@@ -0,0 +1,53 @@
+using System;
+using Cpp2IlInjected;
+
+namespace Microsoft.Win32
+{
+	// Token: 0x0200006E RID: 110
+	[Token(Token = "0x200006E")]
+	internal static class Win32Native
+	{
+		// Token: 0x060002FE RID: 766 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60002FE")]
+		[Address(RVA = "0x2ABD3F0", Offset = "0x2ABC1F0", VA = "0x182ABD3F0")]
+		public static string GetMessage(int hr)
+		{
+			return null;
+		}
+
+		// Token: 0x060002FF RID: 767 RVA: 0x00003360 File Offset: 0x00001560
+		[Token(Token = "0x60002FF")]
+		[Address(RVA = "0x2ABD440", Offset = "0x2ABC240", VA = "0x182ABD440")]
+		public static int MakeHRFromErrorCode(int errorCode)
+		{
+			return 0;
+		}
+
+		// Token: 0x06000300 RID: 768
+		[Token(Token = "0x6000300")]
+		[Address(RVA = "0x2ABD370", Offset = "0x2ABC170", VA = "0x182ABD370")]
+		internal static extern uint GetCurrentProcessId();
+
+		// Token: 0x0200006F RID: 111
+		[Token(Token = "0x200006F")]
+		internal class WIN32_FIND_DATA
+		{
+			// Token: 0x06000301 RID: 769 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6000301")]
+			[Address(RVA = "0x3F5100", Offset = "0x3F3F00", VA = "0x1803F5100")]
+			public WIN32_FIND_DATA()
+			{
+			}
+
+			// Token: 0x040001AF RID: 431
+			[FieldOffset(Offset = "0x10")]
+			[Token(Token = "0x40001AF")]
+			internal int dwFileAttributes;
+
+			// Token: 0x040001B0 RID: 432
+			[FieldOffset(Offset = "0x18")]
+			[Token(Token = "0x40001B0")]
+			internal string cFileName;
+		}
+	}
+}

mscorlib/Microsoft/Win32/Win32RegistryApi.cs

@@ -0,0 +1,197 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+using Cpp2IlInjected;
+
+namespace Microsoft.Win32
+{
+	// Token: 0x0200006D RID: 109
+	[Token(Token = "0x200006D")]
+	internal class Win32RegistryApi : IRegistryApi
+	{
+		// Token: 0x060002E2 RID: 738
+		[Token(Token = "0x60002E2")]
+		[Address(RVA = "0x2ABE950", Offset = "0x2ABD750", VA = "0x182ABE950")]
+		private static extern int RegCreateKeyEx(IntPtr keyBase, string keyName, int reserved, IntPtr lpClass, int options, int access, IntPtr securityAttrs, out IntPtr keyHandle, out int disposition);
+
+		// Token: 0x060002E3 RID: 739
+		[Token(Token = "0x60002E3")]
+		[Address(RVA = "0x2ABE8D0", Offset = "0x2ABD6D0", VA = "0x182ABE8D0")]
+		private static extern int RegCloseKey(IntPtr keyHandle);
+
+		// Token: 0x060002E4 RID: 740
+		[Token(Token = "0x60002E4")]
+		[Address(RVA = "0x2ABEB80", Offset = "0x2ABD980", VA = "0x182ABEB80")]
+		private static extern int RegFlushKey(IntPtr keyHandle);
+
+		// Token: 0x060002E5 RID: 741
+		[Token(Token = "0x60002E5")]
+		[Address(RVA = "0x2ABEC00", Offset = "0x2ABDA00", VA = "0x182ABEC00")]
+		private static extern int RegOpenKeyEx(IntPtr keyBase, string keyName, IntPtr reserved, int access, out IntPtr keyHandle);
+
+		// Token: 0x060002E6 RID: 742
+		[Token(Token = "0x60002E6")]
+		[Address(RVA = "0x2ABEA50", Offset = "0x2ABD850", VA = "0x182ABEA50")]
+		internal unsafe static extern int RegEnumKeyEx(IntPtr keyHandle, int dwIndex, char* lpName, ref int lpcbName, int[] lpReserved, [Out] StringBuilder lpClass, int[] lpcbClass, long[] lpftLastWriteTime);
+
+		// Token: 0x060002E7 RID: 743
+		[Token(Token = "0x60002E7")]
+		[Address(RVA = "0x2ABF2D0", Offset = "0x2ABE0D0", VA = "0x182ABF2D0")]
+		private static extern int RegSetValueEx(IntPtr keyBase, string valueName, IntPtr reserved, RegistryValueKind type, string data, int rawDataLength);
+
+		// Token: 0x060002E8 RID: 744
+		[Token(Token = "0x60002E8")]
+		[Address(RVA = "0x2ABF3B0", Offset = "0x2ABE1B0", VA = "0x182ABF3B0")]
+		private static extern int RegSetValueEx(IntPtr keyBase, string valueName, IntPtr reserved, RegistryValueKind type, byte[] rawData, int rawDataLength);
+
+		// Token: 0x060002E9 RID: 745
+		[Token(Token = "0x60002E9")]
+		[Address(RVA = "0x2ABF200", Offset = "0x2ABE000", VA = "0x182ABF200")]
+		private static extern int RegSetValueEx(IntPtr keyBase, string valueName, IntPtr reserved, RegistryValueKind type, ref int data, int rawDataLength);
+
+		// Token: 0x060002EA RID: 746
+		[Token(Token = "0x60002EA")]
+		[Address(RVA = "0x2ABF130", Offset = "0x2ABDF30", VA = "0x182ABF130")]
+		private static extern int RegQueryValueEx(IntPtr keyBase, string valueName, IntPtr reserved, ref RegistryValueKind type, IntPtr zero, ref int dataSize);
+
+		// Token: 0x060002EB RID: 747
+		[Token(Token = "0x60002EB")]
+		[Address(RVA = "0x2ABEE50", Offset = "0x2ABDC50", VA = "0x182ABEE50")]
+		private static extern int RegQueryValueEx(IntPtr keyBase, string valueName, IntPtr reserved, ref RegistryValueKind type, [Out] byte[] data, ref int dataSize);
+
+		// Token: 0x060002EC RID: 748
+		[Token(Token = "0x60002EC")]
+		[Address(RVA = "0x2ABEF90", Offset = "0x2ABDD90", VA = "0x182ABEF90")]
+		private static extern int RegQueryValueEx(IntPtr keyBase, string valueName, IntPtr reserved, ref RegistryValueKind type, ref int data, ref int dataSize);
+
+		// Token: 0x060002ED RID: 749
+		[Token(Token = "0x60002ED")]
+		[Address(RVA = "0x2ABF060", Offset = "0x2ABDE60", VA = "0x182ABF060")]
+		private static extern int RegQueryValueEx(IntPtr keyBase, string valueName, IntPtr reserved, ref RegistryValueKind type, ref long data, ref int dataSize);
+
+		// Token: 0x060002EE RID: 750
+		[Token(Token = "0x60002EE")]
+		[Address(RVA = "0x2ABECC0", Offset = "0x2ABDAC0", VA = "0x182ABECC0")]
+		internal static extern int RegQueryInfoKey(IntPtr hKey, [Out] StringBuilder lpClass, int[] lpcbClass, IntPtr lpReserved_MustBeZero, ref int lpcSubKeys, int[] lpcbMaxSubKeyLen, int[] lpcbMaxClassLen, ref int lpcValues, int[] lpcbMaxValueNameLen, int[] lpcbMaxValueLen, int[] lpcbSecurityDescriptor, int[] lpftLastWriteTime);
+
+		// Token: 0x060002EF RID: 751 RVA: 0x00003300 File Offset: 0x00001500
+		[Token(Token = "0x60002EF")]
+		[Address(RVA = "0x2ABDDB0", Offset = "0x2ABCBB0", VA = "0x182ABDDB0", Slot = "12")]
+		public IntPtr GetHandle(RegistryKey key)
+		{
+			return 0;
+		}
+
+		// Token: 0x060002F0 RID: 752 RVA: 0x00003318 File Offset: 0x00001518
+		[Token(Token = "0x60002F0")]
+		[Address(RVA = "0x2ABE6D0", Offset = "0x2ABD4D0", VA = "0x182ABE6D0")]
+		private static bool IsHandleValid(RegistryKey key)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x060002F1 RID: 753 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60002F1")]
+		[Address(RVA = "0x2ABE1E0", Offset = "0x2ABCFE0", VA = "0x182ABE1E0", Slot = "8")]
+		public object GetValue(RegistryKey rkey, string name, object defaultValue, RegistryValueOptions options)
+		{
+			return null;
+		}
+
+		// Token: 0x060002F2 RID: 754 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60002F2")]
+		[Address(RVA = "0x2ABF490", Offset = "0x2ABE290", VA = "0x182ABF490", Slot = "9")]
+		public void SetValue(RegistryKey rkey, string name, object value)
+		{
+		}
+
+		// Token: 0x060002F3 RID: 755 RVA: 0x00003330 File Offset: 0x00001530
+		[Token(Token = "0x60002F3")]
+		[Address(RVA = "0x2ABDBC0", Offset = "0x2ABC9C0", VA = "0x182ABDBC0")]
+		private int GetBinaryValue(RegistryKey rkey, string name, RegistryValueKind type, out byte[] data, int size)
+		{
+			return 0;
+		}
+
+		// Token: 0x060002F4 RID: 756 RVA: 0x00003348 File Offset: 0x00001548
+		[Token(Token = "0x60002F4")]
+		[Address(RVA = "0x2ABF9B0", Offset = "0x2ABE7B0", VA = "0x182ABF9B0", Slot = "13")]
+		public int SubKeyCount(RegistryKey rkey)
+		{
+			return 0;
+		}
+
+		// Token: 0x060002F5 RID: 757 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60002F5")]
+		[Address(RVA = "0x2ABE6F0", Offset = "0x2ABD4F0", VA = "0x182ABE6F0", Slot = "5")]
+		public RegistryKey OpenSubKey(RegistryKey rkey, string keyName, bool writable)
+		{
+			return null;
+		}
+
+		// Token: 0x060002F6 RID: 758 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60002F6")]
+		[Address(RVA = "0x2ABD920", Offset = "0x2ABC720", VA = "0x182ABD920", Slot = "6")]
+		public void Flush(RegistryKey rkey)
+		{
+		}
+
+		// Token: 0x060002F7 RID: 759 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60002F7")]
+		[Address(RVA = "0x2ABD450", Offset = "0x2ABC250", VA = "0x182ABD450", Slot = "7")]
+		public void Close(RegistryKey rkey)
+		{
+		}
+
+		// Token: 0x060002F8 RID: 760 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60002F8")]
+		[Address(RVA = "0x2ABD710", Offset = "0x2ABC510", VA = "0x182ABD710", Slot = "4")]
+		public RegistryKey CreateSubKey(RegistryKey rkey, string keyName)
+		{
+			return null;
+		}
+
+		// Token: 0x060002F9 RID: 761 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60002F9")]
+		[Address(RVA = "0x2ABDE20", Offset = "0x2ABCC20", VA = "0x182ABDE20", Slot = "10")]
+		public string[] GetSubKeyNames(RegistryKey rkey)
+		{
+			return null;
+		}
+
+		// Token: 0x060002FA RID: 762 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60002FA")]
+		[Address(RVA = "0x2ABDA10", Offset = "0x2ABC810", VA = "0x182ABDA10")]
+		private void GenerateException(int errorCode)
+		{
+		}
+
+		// Token: 0x060002FB RID: 763 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60002FB")]
+		[Address(RVA = "0x901BC0", Offset = "0x9009C0", VA = "0x180901BC0", Slot = "11")]
+		public string ToString(RegistryKey rkey)
+		{
+			return null;
+		}
+
+		// Token: 0x060002FC RID: 764 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60002FC")]
+		[Address(RVA = "0x2ABD6B0", Offset = "0x2ABC4B0", VA = "0x182ABD6B0")]
+		internal static string CombineName(RegistryKey rkey, string localName)
+		{
+			return null;
+		}
+
+		// Token: 0x060002FD RID: 765 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60002FD")]
+		[Address(RVA = "0x2ABFB60", Offset = "0x2ABE960", VA = "0x182ABFB60")]
+		public Win32RegistryApi()
+		{
+		}
+
+		// Token: 0x040001AE RID: 430
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x40001AE")]
+		private readonly int NativeBytesPerCharacter;
+	}
+}

mscorlib/Mono/Globalization/Unicode/CodePointIndexer.cs

@@ -0,0 +1,83 @@
+using System;
+using Cpp2IlInjected;
+
+namespace Mono.Globalization.Unicode
+{
+	// Token: 0x0200001E RID: 30
+	[Token(Token = "0x200001E")]
+	internal class CodePointIndexer
+	{
+		// Token: 0x06000072 RID: 114 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000072")]
+		[Address(RVA = "0x2AA80F0", Offset = "0x2AA6EF0", VA = "0x182AA80F0")]
+		public CodePointIndexer(int[] starts, int[] ends, int defaultIndex, int defaultCP)
+		{
+		}
+
+		// Token: 0x06000073 RID: 115 RVA: 0x00002358 File Offset: 0x00000558
+		[Token(Token = "0x6000073")]
+		[Address(RVA = "0x2AA8050", Offset = "0x2AA6E50", VA = "0x182AA8050")]
+		public int ToIndex(int cp)
+		{
+			return 0;
+		}
+
+		// Token: 0x0400004D RID: 77
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x400004D")]
+		private readonly CodePointIndexer.TableRange[] ranges;
+
+		// Token: 0x0400004E RID: 78
+		[FieldOffset(Offset = "0x18")]
+		[Token(Token = "0x400004E")]
+		public readonly int TotalCount;
+
+		// Token: 0x0400004F RID: 79
+		[FieldOffset(Offset = "0x1C")]
+		[Token(Token = "0x400004F")]
+		private int defaultIndex;
+
+		// Token: 0x04000050 RID: 80
+		[FieldOffset(Offset = "0x20")]
+		[Token(Token = "0x4000050")]
+		private int defaultCP;
+
+		// Token: 0x0200001F RID: 31
+		[Token(Token = "0x200001F")]
+		[Serializable]
+		internal struct TableRange
+		{
+			// Token: 0x06000074 RID: 116 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6000074")]
+			[Address(RVA = "0x2ABC860", Offset = "0x2ABB660", VA = "0x182ABC860")]
+			public TableRange(int start, int end, int indexStart)
+			{
+			}
+
+			// Token: 0x04000051 RID: 81
+			[FieldOffset(Offset = "0x0")]
+			[Token(Token = "0x4000051")]
+			public readonly int Start;
+
+			// Token: 0x04000052 RID: 82
+			[FieldOffset(Offset = "0x4")]
+			[Token(Token = "0x4000052")]
+			public readonly int End;
+
+			// Token: 0x04000053 RID: 83
+			[FieldOffset(Offset = "0x8")]
+			[Token(Token = "0x4000053")]
+			public readonly int Count;
+
+			// Token: 0x04000054 RID: 84
+			[FieldOffset(Offset = "0xC")]
+			[Token(Token = "0x4000054")]
+			public readonly int IndexStart;
+
+			// Token: 0x04000055 RID: 85
+			[FieldOffset(Offset = "0x10")]
+			[Token(Token = "0x4000055")]
+			public readonly int IndexEnd;
+		}
+	}
+}

mscorlib/Mono/Globalization/Unicode/Contraction.cs

@@ -0,0 +1,37 @@
+using System;
+using Cpp2IlInjected;
+
+namespace Mono.Globalization.Unicode
+{
+	// Token: 0x02000021 RID: 33
+	[Token(Token = "0x2000021")]
+	internal class Contraction
+	{
+		// Token: 0x06000076 RID: 118 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000076")]
+		[Address(RVA = "0x2AA8440", Offset = "0x2AA7240", VA = "0x182AA8440")]
+		public Contraction(int index, char[] source, string replacement, byte[] sortkey)
+		{
+		}
+
+		// Token: 0x0400005A RID: 90
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x400005A")]
+		public int Index;
+
+		// Token: 0x0400005B RID: 91
+		[FieldOffset(Offset = "0x18")]
+		[Token(Token = "0x400005B")]
+		public readonly char[] Source;
+
+		// Token: 0x0400005C RID: 92
+		[FieldOffset(Offset = "0x20")]
+		[Token(Token = "0x400005C")]
+		public readonly string Replacement;
+
+		// Token: 0x0400005D RID: 93
+		[FieldOffset(Offset = "0x28")]
+		[Token(Token = "0x400005D")]
+		public readonly byte[] SortKey;
+	}
+}

mscorlib/Mono/Globalization/Unicode/ContractionComparer.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+using Cpp2IlInjected;
+
+namespace Mono.Globalization.Unicode
+{
+	// Token: 0x02000022 RID: 34
+	[Token(Token = "0x2000022")]
+	internal class ContractionComparer : IComparer<Contraction>
+	{
+		// Token: 0x06000077 RID: 119 RVA: 0x00002370 File Offset: 0x00000570
+		[Token(Token = "0x6000077")]
+		[Address(RVA = "0x2AA82F0", Offset = "0x2AA70F0", VA = "0x182AA82F0", Slot = "4")]
+		public int Compare(Contraction c1, Contraction c2)
+		{
+			return 0;
+		}
+
+		// Token: 0x06000078 RID: 120 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000078")]
+		[Address(RVA = "0x3F5100", Offset = "0x3F3F00", VA = "0x1803F5100")]
+		public ContractionComparer()
+		{
+		}
+
+		// Token: 0x0400005E RID: 94
+		[Token(Token = "0x400005E")]
+		public static readonly ContractionComparer Instance;
+	}
+}

mscorlib/Mono/Globalization/Unicode/Level2Map.cs

@@ -0,0 +1,27 @@
+using System;
+using Cpp2IlInjected;
+
+namespace Mono.Globalization.Unicode
+{
+	// Token: 0x02000023 RID: 35
+	[Token(Token = "0x2000023")]
+	internal class Level2Map
+	{
+		// Token: 0x0600007A RID: 122 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600007A")]
+		[Address(RVA = "0x2AAEC30", Offset = "0x2AADA30", VA = "0x182AAEC30")]
+		public Level2Map(byte source, byte replace)
+		{
+		}
+
+		// Token: 0x0400005F RID: 95
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x400005F")]
+		public byte Source;
+
+		// Token: 0x04000060 RID: 96
+		[FieldOffset(Offset = "0x11")]
+		[Token(Token = "0x4000060")]
+		public byte Replace;
+	}
+}

mscorlib/Mono/Globalization/Unicode/MSCompatUnicodeTable.cs

@@ -0,0 +1,248 @@
+using System;
+using System.Globalization;
+using Cpp2IlInjected;
+
+namespace Mono.Globalization.Unicode
+{
+	// Token: 0x02000024 RID: 36
+	[Token(Token = "0x2000024")]
+	internal class MSCompatUnicodeTable
+	{
+		// Token: 0x0600007B RID: 123 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x600007B")]
+		[Address(RVA = "0x2AAFF20", Offset = "0x2AAED20", VA = "0x182AAFF20")]
+		public static TailoringInfo GetTailoringInfo(int lcid)
+		{
+			return null;
+		}
+
+		// Token: 0x0600007C RID: 124 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600007C")]
+		[Address(RVA = "0x2AAF140", Offset = "0x2AADF40", VA = "0x182AAF140")]
+		public static void BuildTailoringTables(CultureInfo culture, TailoringInfo t, ref Contraction[] contractions, ref Level2Map[] diacriticals)
+		{
+		}
+
+		// Token: 0x0600007D RID: 125 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600007D")]
+		[Address(RVA = "0x2AB0660", Offset = "0x2AAF460", VA = "0x182AB0660")]
+		private unsafe static void SetCJKReferences(string name, ref CodePointIndexer cjkIndexer, ref byte* catTable, ref byte* lv1Table, ref CodePointIndexer lv2Indexer, ref byte* lv2Table)
+		{
+		}
+
+		// Token: 0x0600007E RID: 126 RVA: 0x00002388 File Offset: 0x00000588
+		[Token(Token = "0x600007E")]
+		[Address(RVA = "0x2AAF700", Offset = "0x2AAE500", VA = "0x182AAF700")]
+		public static byte Category(int cp)
+		{
+			return 0;
+		}
+
+		// Token: 0x0600007F RID: 127 RVA: 0x000023A0 File Offset: 0x000005A0
+		[Token(Token = "0x600007F")]
+		[Address(RVA = "0x2AB0420", Offset = "0x2AAF220", VA = "0x182AB0420")]
+		public static byte Level1(int cp)
+		{
+			return 0;
+		}
+
+		// Token: 0x06000080 RID: 128 RVA: 0x000023B8 File Offset: 0x000005B8
+		[Token(Token = "0x6000080")]
+		[Address(RVA = "0x2AB04E0", Offset = "0x2AAF2E0", VA = "0x182AB04E0")]
+		public static byte Level2(int cp)
+		{
+			return 0;
+		}
+
+		// Token: 0x06000081 RID: 129 RVA: 0x000023D0 File Offset: 0x000005D0
+		[Token(Token = "0x6000081")]
+		[Address(RVA = "0x2AB05A0", Offset = "0x2AAF3A0", VA = "0x182AB05A0")]
+		public static byte Level3(int cp)
+		{
+			return 0;
+		}
+
+		// Token: 0x06000082 RID: 130 RVA: 0x000023E8 File Offset: 0x000005E8
+		[Token(Token = "0x6000082")]
+		[Address(RVA = "0x2AB0180", Offset = "0x2AAEF80", VA = "0x182AB0180")]
+		public static bool IsIgnorable(int cp, byte flag)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x06000083 RID: 131 RVA: 0x00002400 File Offset: 0x00000600
+		[Token(Token = "0x6000083")]
+		[Address(RVA = "0x2AB0120", Offset = "0x2AAEF20", VA = "0x182AB0120")]
+		public static bool IsIgnorableNonSpacing(int cp)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x06000084 RID: 132 RVA: 0x00002418 File Offset: 0x00000618
+		[Token(Token = "0x6000084")]
+		[Address(RVA = "0x2AB0930", Offset = "0x2AAF730", VA = "0x182AB0930")]
+		public static int ToKanaTypeInsensitive(int i)
+		{
+			return 0;
+		}
+
+		// Token: 0x06000085 RID: 133 RVA: 0x00002430 File Offset: 0x00000630
+		[Token(Token = "0x6000085")]
+		[Address(RVA = "0x2AB0950", Offset = "0x2AAF750", VA = "0x182AB0950")]
+		public static int ToWidthCompat(int i)
+		{
+			return 0;
+		}
+
+		// Token: 0x06000086 RID: 134 RVA: 0x00002448 File Offset: 0x00000648
+		[Token(Token = "0x6000086")]
+		[Address(RVA = "0x2AB0070", Offset = "0x2AAEE70", VA = "0x182AB0070")]
+		public static bool HasSpecialWeight(char c)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x06000087 RID: 135 RVA: 0x00002460 File Offset: 0x00000660
+		[Token(Token = "0x6000087")]
+		[Address(RVA = "0x2AB00E0", Offset = "0x2AAEEE0", VA = "0x182AB00E0")]
+		public static bool IsHalfWidthKana(char c)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x06000088 RID: 136 RVA: 0x00002478 File Offset: 0x00000678
+		[Token(Token = "0x6000088")]
+		[Address(RVA = "0x2AB0100", Offset = "0x2AAEF00", VA = "0x182AB0100")]
+		public static bool IsHiragana(char c)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x06000089 RID: 137 RVA: 0x00002490 File Offset: 0x00000690
+		[Token(Token = "0x6000089")]
+		[Address(RVA = "0x2AB02B0", Offset = "0x2AAF0B0", VA = "0x182AB02B0")]
+		public static bool IsJapaneseSmallLetter(char c)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x17000012 RID: 18
+		// (get) Token: 0x0600008A RID: 138 RVA: 0x000024A8 File Offset: 0x000006A8
+		[Token(Token = "0x17000012")]
+		public static bool IsReady
+		{
+			[Token(Token = "0x600008A")]
+			[Address(RVA = "0x2AB1070", Offset = "0x2AAFE70", VA = "0x182AB1070")]
+			get
+			{
+				return default(bool);
+			}
+		}
+
+		// Token: 0x0600008B RID: 139 RVA: 0x000024C0 File Offset: 0x000006C0
+		[Token(Token = "0x600008B")]
+		[Address(RVA = "0x2AAFEB0", Offset = "0x2AAECB0", VA = "0x182AAFEB0")]
+		private static IntPtr GetResource(string name)
+		{
+			return 0;
+		}
+
+		// Token: 0x0600008C RID: 140 RVA: 0x000024D8 File Offset: 0x000006D8
+		[Token(Token = "0x600008C")]
+		[Address(RVA = "0x2AB0AD0", Offset = "0x2AAF8D0", VA = "0x182AB0AD0")]
+		private unsafe static uint UInt32FromBytePtr(byte* raw, uint idx)
+		{
+			return 0U;
+		}
+
+		// Token: 0x0600008E RID: 142 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600008E")]
+		[Address(RVA = "0x2AAFD50", Offset = "0x2AAEB50", VA = "0x182AAFD50")]
+		public unsafe static void FillCJK(string culture, ref CodePointIndexer cjkIndexer, ref byte* catTable, ref byte* lv1Table, ref CodePointIndexer lv2Indexer, ref byte* lv2Table)
+		{
+		}
+
+		// Token: 0x0600008F RID: 143 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600008F")]
+		[Address(RVA = "0x2AAF7C0", Offset = "0x2AAE5C0", VA = "0x182AAF7C0")]
+		private unsafe static void FillCJKCore(string culture, ref CodePointIndexer cjkIndexer, ref byte* catTable, ref byte* lv1Table, ref CodePointIndexer cjkLv2Indexer, ref byte* lv2Table)
+		{
+		}
+
+		// Token: 0x04000061 RID: 97
+		[Token(Token = "0x4000061")]
+		public static int MaxExpansionLength;
+
+		// Token: 0x04000062 RID: 98
+		[Token(Token = "0x4000062")]
+		private unsafe static readonly byte* ignorableFlags;
+
+		// Token: 0x04000063 RID: 99
+		[Token(Token = "0x4000063")]
+		private unsafe static readonly byte* categories;
+
+		// Token: 0x04000064 RID: 100
+		[Token(Token = "0x4000064")]
+		private unsafe static readonly byte* level1;
+
+		// Token: 0x04000065 RID: 101
+		[Token(Token = "0x4000065")]
+		private unsafe static readonly byte* level2;
+
+		// Token: 0x04000066 RID: 102
+		[Token(Token = "0x4000066")]
+		private unsafe static readonly byte* level3;
+
+		// Token: 0x04000067 RID: 103
+		[Token(Token = "0x4000067")]
+		private unsafe static byte* cjkCHScategory;
+
+		// Token: 0x04000068 RID: 104
+		[Token(Token = "0x4000068")]
+		private unsafe static byte* cjkCHTcategory;
+
+		// Token: 0x04000069 RID: 105
+		[Token(Token = "0x4000069")]
+		private unsafe static byte* cjkJAcategory;
+
+		// Token: 0x0400006A RID: 106
+		[Token(Token = "0x400006A")]
+		private unsafe static byte* cjkKOcategory;
+
+		// Token: 0x0400006B RID: 107
+		[Token(Token = "0x400006B")]
+		private unsafe static byte* cjkCHSlv1;
+
+		// Token: 0x0400006C RID: 108
+		[Token(Token = "0x400006C")]
+		private unsafe static byte* cjkCHTlv1;
+
+		// Token: 0x0400006D RID: 109
+		[Token(Token = "0x400006D")]
+		private unsafe static byte* cjkJAlv1;
+
+		// Token: 0x0400006E RID: 110
+		[Token(Token = "0x400006E")]
+		private unsafe static byte* cjkKOlv1;
+
+		// Token: 0x0400006F RID: 111
+		[Token(Token = "0x400006F")]
+		private unsafe static byte* cjkKOlv2;
+
+		// Token: 0x04000070 RID: 112
+		[Token(Token = "0x4000070")]
+		private static readonly char[] tailoringArr;
+
+		// Token: 0x04000071 RID: 113
+		[Token(Token = "0x4000071")]
+		private static readonly TailoringInfo[] tailoringInfos;
+
+		// Token: 0x04000072 RID: 114
+		[Token(Token = "0x4000072")]
+		private static object forLock;
+
+		// Token: 0x04000073 RID: 115
+		[Token(Token = "0x4000073")]
+		public static readonly bool isReady;
+	}
+}

mscorlib/Mono/Globalization/Unicode/MSCompatUnicodeTableUtil.cs

@@ -0,0 +1,38 @@
+using System;
+using Cpp2IlInjected;
+
+namespace Mono.Globalization.Unicode
+{
+	// Token: 0x02000026 RID: 38
+	[Token(Token = "0x2000026")]
+	internal class MSCompatUnicodeTableUtil
+	{
+		// Token: 0x04000076 RID: 118
+		[Token(Token = "0x4000076")]
+		public static readonly CodePointIndexer Ignorable;
+
+		// Token: 0x04000077 RID: 119
+		[Token(Token = "0x4000077")]
+		public static readonly CodePointIndexer Category;
+
+		// Token: 0x04000078 RID: 120
+		[Token(Token = "0x4000078")]
+		public static readonly CodePointIndexer Level1;
+
+		// Token: 0x04000079 RID: 121
+		[Token(Token = "0x4000079")]
+		public static readonly CodePointIndexer Level2;
+
+		// Token: 0x0400007A RID: 122
+		[Token(Token = "0x400007A")]
+		public static readonly CodePointIndexer Level3;
+
+		// Token: 0x0400007B RID: 123
+		[Token(Token = "0x400007B")]
+		public static readonly CodePointIndexer CjkCHS;
+
+		// Token: 0x0400007C RID: 124
+		[Token(Token = "0x400007C")]
+		public static readonly CodePointIndexer Cjk;
+	}
+}

mscorlib/Mono/Globalization/Unicode/NormalizationTableUtil.cs

@@ -0,0 +1,46 @@
+using System;
+using Cpp2IlInjected;
+
+namespace Mono.Globalization.Unicode
+{
+	// Token: 0x02000027 RID: 39
+	[Token(Token = "0x2000027")]
+	internal class NormalizationTableUtil
+	{
+		// Token: 0x06000095 RID: 149 RVA: 0x00002508 File Offset: 0x00000708
+		[Token(Token = "0x6000095")]
+		[Address(RVA = "0x2AB21E0", Offset = "0x2AB0FE0", VA = "0x182AB21E0")]
+		public static int PropIdx(int cp)
+		{
+			return 0;
+		}
+
+		// Token: 0x06000096 RID: 150 RVA: 0x00002520 File Offset: 0x00000720
+		[Token(Token = "0x6000096")]
+		[Address(RVA = "0x2AB2170", Offset = "0x2AB0F70", VA = "0x182AB2170")]
+		public static int MapIdx(int cp)
+		{
+			return 0;
+		}
+
+		// Token: 0x0400007D RID: 125
+		[Token(Token = "0x400007D")]
+		public static readonly CodePointIndexer Prop;
+
+		// Token: 0x0400007E RID: 126
+		[Token(Token = "0x400007E")]
+		public static readonly CodePointIndexer Map;
+
+		// Token: 0x0400007F RID: 127
+		[Token(Token = "0x400007F")]
+		public static readonly CodePointIndexer Combining;
+
+		// Token: 0x04000080 RID: 128
+		[Token(Token = "0x4000080")]
+		public static readonly CodePointIndexer Composite;
+
+		// Token: 0x04000081 RID: 129
+		[Token(Token = "0x4000081")]
+		public static readonly CodePointIndexer Helper;
+	}
+}

mscorlib/Mono/Globalization/Unicode/SimpleCollator.cs

@@ -0,0 +1,560 @@
+using System;
+using System.Globalization;
+using Cpp2IlInjected;
+
+namespace Mono.Globalization.Unicode
+{
+	// Token: 0x02000028 RID: 40
+	[Token(Token = "0x2000028")]
+	internal class SimpleCollator
+	{
+		// Token: 0x06000097 RID: 151 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000097")]
+		[Address(RVA = "0x2ABB3D0", Offset = "0x2ABA1D0", VA = "0x182ABB3D0")]
+		public SimpleCollator(CultureInfo culture)
+		{
+		}
+
+		// Token: 0x06000098 RID: 152 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000098")]
+		[Address(RVA = "0x2ABB190", Offset = "0x2AB9F90", VA = "0x182ABB190")]
+		private unsafe void SetCJKTable(CultureInfo culture, ref CodePointIndexer cjkIndexer, ref byte* catTable, ref byte* lv1Table, ref CodePointIndexer lv2Indexer, ref byte* lv2Table)
+		{
+		}
+
+		// Token: 0x06000099 RID: 153 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000099")]
+		[Address(RVA = "0x2AB7D60", Offset = "0x2AB6B60", VA = "0x182AB7D60")]
+		private static CultureInfo GetNeutralCulture(CultureInfo info)
+		{
+			return null;
+		}
+
+		// Token: 0x0600009A RID: 154 RVA: 0x00002538 File Offset: 0x00000738
+		[Token(Token = "0x600009A")]
+		[Address(RVA = "0x2AB5A30", Offset = "0x2AB4830", VA = "0x182AB5A30")]
+		private byte Category(int cp)
+		{
+			return 0;
+		}
+
+		// Token: 0x0600009B RID: 155 RVA: 0x00002550 File Offset: 0x00000750
+		[Token(Token = "0x600009B")]
+		[Address(RVA = "0x2AB9E70", Offset = "0x2AB8C70", VA = "0x182AB9E70")]
+		private byte Level1(int cp)
+		{
+			return 0;
+		}
+
+		// Token: 0x0600009C RID: 156 RVA: 0x00002568 File Offset: 0x00000768
+		[Token(Token = "0x600009C")]
+		[Address(RVA = "0x2AB9F10", Offset = "0x2AB8D10", VA = "0x182AB9F10")]
+		private byte Level2(int cp, SimpleCollator.ExtenderType ext)
+		{
+			return 0;
+		}
+
+		// Token: 0x0600009D RID: 157 RVA: 0x00002580 File Offset: 0x00000780
+		[Token(Token = "0x600009D")]
+		[Address(RVA = "0x2AB9100", Offset = "0x2AB7F00", VA = "0x182AB9100")]
+		private static bool IsHalfKana(int cp, CompareOptions opt)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x0600009E RID: 158 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x600009E")]
+		[Address(RVA = "0x2AB7A80", Offset = "0x2AB6880", VA = "0x182AB7A80")]
+		private Contraction GetContraction(string s, int start, int end)
+		{
+			return null;
+		}
+
+		// Token: 0x0600009F RID: 159 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x600009F")]
+		[Address(RVA = "0x2AB7B60", Offset = "0x2AB6960", VA = "0x182AB7B60")]
+		private Contraction GetContraction(string s, int start, int end, Contraction[] clist)
+		{
+			return null;
+		}
+
+		// Token: 0x060000A0 RID: 160 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60000A0")]
+		[Address(RVA = "0x2AB83E0", Offset = "0x2AB71E0", VA = "0x182AB83E0")]
+		private Contraction GetTailContraction(string s, int start, int end)
+		{
+			return null;
+		}
+
+		// Token: 0x060000A1 RID: 161 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60000A1")]
+		[Address(RVA = "0x2AB84C0", Offset = "0x2AB72C0", VA = "0x182AB84C0")]
+		private Contraction GetTailContraction(string s, int start, int end, Contraction[] clist)
+		{
+			return null;
+		}
+
+		// Token: 0x060000A2 RID: 162 RVA: 0x00002598 File Offset: 0x00000798
+		[Token(Token = "0x60000A2")]
+		[Address(RVA = "0x2AB77C0", Offset = "0x2AB65C0", VA = "0x182AB77C0")]
+		private int FilterOptions(int i, CompareOptions opt)
+		{
+			return 0;
+		}
+
+		// Token: 0x060000A3 RID: 163 RVA: 0x000025B0 File Offset: 0x000007B0
+		[Token(Token = "0x60000A3")]
+		[Address(RVA = "0x2AB7CB0", Offset = "0x2AB6AB0", VA = "0x182AB7CB0")]
+		private SimpleCollator.ExtenderType GetExtenderType(int i)
+		{
+			return SimpleCollator.ExtenderType.None;
+		}
+
+		// Token: 0x060000A4 RID: 164 RVA: 0x000025C8 File Offset: 0x000007C8
+		[Token(Token = "0x60000A4")]
+		[Address(RVA = "0x2ABB2F0", Offset = "0x2ABA0F0", VA = "0x182ABB2F0")]
+		private static byte ToDashTypeValue(SimpleCollator.ExtenderType ext, CompareOptions opt)
+		{
+			return 0;
+		}
+
+		// Token: 0x060000A5 RID: 165 RVA: 0x000025E0 File Offset: 0x000007E0
+		[Token(Token = "0x60000A5")]
+		[Address(RVA = "0x2AB75A0", Offset = "0x2AB63A0", VA = "0x182AB75A0")]
+		private int FilterExtender(int i, SimpleCollator.ExtenderType ext, CompareOptions opt)
+		{
+			return 0;
+		}
+
+		// Token: 0x060000A6 RID: 166 RVA: 0x000025F8 File Offset: 0x000007F8
+		[Token(Token = "0x60000A6")]
+		[Address(RVA = "0x2AB9190", Offset = "0x2AB7F90", VA = "0x182AB9190")]
+		private static bool IsIgnorable(int i, CompareOptions opt)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x060000A7 RID: 167 RVA: 0x00002610 File Offset: 0x00000810
+		[Token(Token = "0x60000A7")]
+		[Address(RVA = "0x2AB93E0", Offset = "0x2AB81E0", VA = "0x182AB93E0")]
+		private bool IsSafe(int i)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x060000A8 RID: 168 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60000A8")]
+		[Address(RVA = "0x2AB7DF0", Offset = "0x2AB6BF0", VA = "0x182AB7DF0")]
+		public SortKey GetSortKey(string s, CompareOptions options)
+		{
+			return null;
+		}
+
+		// Token: 0x060000A9 RID: 169 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60000A9")]
+		[Address(RVA = "0x2AB7E20", Offset = "0x2AB6C20", VA = "0x182AB7E20")]
+		public SortKey GetSortKey(string s, int start, int length, CompareOptions options)
+		{
+			return null;
+		}
+
+		// Token: 0x060000AA RID: 170 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60000AA")]
+		[Address(RVA = "0x2AB8050", Offset = "0x2AB6E50", VA = "0x182AB8050")]
+		private void GetSortKey(string s, int start, int end, SortKeyBuffer buf, CompareOptions opt)
+		{
+		}
+
+		// Token: 0x060000AB RID: 171 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60000AB")]
+		[Address(RVA = "0x2AB6FA0", Offset = "0x2AB5DA0", VA = "0x182AB6FA0")]
+		private void FillSortKeyRaw(int i, SimpleCollator.ExtenderType ext, SortKeyBuffer buf, CompareOptions opt)
+		{
+		}
+
+		// Token: 0x060000AC RID: 172 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60000AC")]
+		[Address(RVA = "0x2AB74F0", Offset = "0x2AB62F0", VA = "0x182AB74F0")]
+		private void FillSurrogateSortKeyRaw(int i, SortKeyBuffer buf)
+		{
+		}
+
+		// Token: 0x060000AD RID: 173 RVA: 0x00002628 File Offset: 0x00000828
+		[Token(Token = "0x60000AD")]
+		[Address(RVA = "0x2AB6EA0", Offset = "0x2AB5CA0", VA = "0x182AB6EA0")]
+		internal int Compare(string s1, int idx1, int len1, string s2, int idx2, int len2, CompareOptions options)
+		{
+			return 0;
+		}
+
+		// Token: 0x060000AE RID: 174 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60000AE")]
+		[Address(RVA = "0x2AB5AD0", Offset = "0x2AB48D0", VA = "0x182AB5AD0")]
+		private unsafe void ClearBuffer(byte* buffer, int size)
+		{
+		}
+
+		// Token: 0x060000AF RID: 175 RVA: 0x00002640 File Offset: 0x00000840
+		[Token(Token = "0x60000AF")]
+		[Address(RVA = "0x2AB5B10", Offset = "0x2AB4910", VA = "0x182AB5B10")]
+		private int CompareInternal(string s1, int idx1, int len1, string s2, int idx2, int len2, out bool targetConsumed, out bool sourceConsumed, bool skipHeadingExtenders, bool immediateBreakup, ref SimpleCollator.Context ctx)
+		{
+			return 0;
+		}
+
+		// Token: 0x060000B0 RID: 176 RVA: 0x00002658 File Offset: 0x00000858
+		[Token(Token = "0x60000B0")]
+		[Address(RVA = "0x2AB5AF0", Offset = "0x2AB48F0", VA = "0x182AB5AF0")]
+		private int CompareFlagPair(bool b1, bool b2)
+		{
+			return 0;
+		}
+
+		// Token: 0x060000B1 RID: 177 RVA: 0x00002670 File Offset: 0x00000870
+		[Token(Token = "0x60000B1")]
+		[Address(RVA = "0x2AB9220", Offset = "0x2AB8020", VA = "0x182AB9220")]
+		public bool IsPrefix(string src, string target, CompareOptions opt)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x060000B2 RID: 178 RVA: 0x00002688 File Offset: 0x00000888
+		[Token(Token = "0x60000B2")]
+		[Address(RVA = "0x2AB9260", Offset = "0x2AB8060", VA = "0x182AB9260")]
+		public bool IsPrefix(string s, string target, int start, int length, CompareOptions opt)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x060000B3 RID: 179 RVA: 0x000026A0 File Offset: 0x000008A0
+		[Token(Token = "0x60000B3")]
+		[Address(RVA = "0x2AB9360", Offset = "0x2AB8160", VA = "0x182AB9360")]
+		private bool IsPrefix(string s, string target, int start, int length, bool skipHeadingExtenders, ref SimpleCollator.Context ctx)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x060000B4 RID: 180 RVA: 0x000026B8 File Offset: 0x000008B8
+		[Token(Token = "0x60000B4")]
+		[Address(RVA = "0x2AB9510", Offset = "0x2AB8310", VA = "0x182AB9510")]
+		public bool IsSuffix(string src, string target, CompareOptions opt)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x060000B5 RID: 181 RVA: 0x000026D0 File Offset: 0x000008D0
+		[Token(Token = "0x60000B5")]
+		[Address(RVA = "0x2AB9450", Offset = "0x2AB8250", VA = "0x182AB9450")]
+		public bool IsSuffix(string s, string target, int start, int length, CompareOptions opt)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x060000B6 RID: 182 RVA: 0x000026E8 File Offset: 0x000008E8
+		[Token(Token = "0x60000B6")]
+		[Address(RVA = "0x2ABB050", Offset = "0x2AB9E50", VA = "0x182ABB050")]
+		private int QuickIndexOf(string s, string target, int start, int length, out bool testWasUnable)
+		{
+			return 0;
+		}
+
+		// Token: 0x060000B7 RID: 183 RVA: 0x00002700 File Offset: 0x00000900
+		[Token(Token = "0x60000B7")]
+		[Address(RVA = "0x2AB8E10", Offset = "0x2AB7C10", VA = "0x182AB8E10")]
+		public int IndexOf(string s, string target, int start, int length, CompareOptions opt)
+		{
+			return 0;
+		}
+
+		// Token: 0x060000B8 RID: 184 RVA: 0x00002718 File Offset: 0x00000918
+		[Token(Token = "0x60000B8")]
+		[Address(RVA = "0x2AB8770", Offset = "0x2AB7570", VA = "0x182AB8770")]
+		private int IndexOfOrdinal(string s, string target, int start, int length)
+		{
+			return 0;
+		}
+
+		// Token: 0x060000B9 RID: 185 RVA: 0x00002730 File Offset: 0x00000930
+		[Token(Token = "0x60000B9")]
+		[Address(RVA = "0x2AB86F0", Offset = "0x2AB74F0", VA = "0x182AB86F0")]
+		private int IndexOfOrdinal(string s, char target, int start, int length)
+		{
+			return 0;
+		}
+
+		// Token: 0x060000BA RID: 186 RVA: 0x00002748 File Offset: 0x00000948
+		[Token(Token = "0x60000BA")]
+		[Address(RVA = "0x2AB8830", Offset = "0x2AB7630", VA = "0x182AB8830")]
+		private unsafe int IndexOfSortKey(string s, int start, int length, byte* sortkey, char target, int ti, bool noLv4, ref SimpleCollator.Context ctx)
+		{
+			return 0;
+		}
+
+		// Token: 0x060000BB RID: 187 RVA: 0x00002760 File Offset: 0x00000960
+		[Token(Token = "0x60000BB")]
+		[Address(RVA = "0x2AB88F0", Offset = "0x2AB76F0", VA = "0x182AB88F0")]
+		private unsafe int IndexOf(string s, string target, int start, int length, byte* targetSortKey, ref SimpleCollator.Context ctx)
+		{
+			return 0;
+		}
+
+		// Token: 0x060000BC RID: 188 RVA: 0x00002778 File Offset: 0x00000978
+		[Token(Token = "0x60000BC")]
+		[Address(RVA = "0x2AB9CD0", Offset = "0x2AB8AD0", VA = "0x182AB9CD0")]
+		public int LastIndexOf(string s, string target, int start, int length, CompareOptions opt)
+		{
+			return 0;
+		}
+
+		// Token: 0x060000BD RID: 189 RVA: 0x00002790 File Offset: 0x00000990
+		[Token(Token = "0x60000BD")]
+		[Address(RVA = "0x2AB95D0", Offset = "0x2AB83D0", VA = "0x182AB95D0")]
+		private int LastIndexOfOrdinal(string s, string target, int start, int length)
+		{
+			return 0;
+		}
+
+		// Token: 0x060000BE RID: 190 RVA: 0x000027A8 File Offset: 0x000009A8
+		[Token(Token = "0x60000BE")]
+		[Address(RVA = "0x2AB9720", Offset = "0x2AB8520", VA = "0x182AB9720")]
+		private unsafe int LastIndexOfSortKey(string s, int start, int orgStart, int length, byte* sortkey, int ti, bool noLv4, ref SimpleCollator.Context ctx)
+		{
+			return 0;
+		}
+
+		// Token: 0x060000BF RID: 191 RVA: 0x000027C0 File Offset: 0x000009C0
+		[Token(Token = "0x60000BF")]
+		[Address(RVA = "0x2AB97F0", Offset = "0x2AB85F0", VA = "0x182AB97F0")]
+		private unsafe int LastIndexOf(string s, string target, int start, int length, byte* targetSortKey, ref SimpleCollator.Context ctx)
+		{
+			return 0;
+		}
+
+		// Token: 0x060000C0 RID: 192 RVA: 0x000027D8 File Offset: 0x000009D8
+		[Token(Token = "0x60000C0")]
+		[Address(RVA = "0x2ABAC80", Offset = "0x2AB9A80", VA = "0x182ABAC80")]
+		private unsafe bool MatchesForward(string s, ref int idx, int end, int ti, byte* sortkey, bool noLv4, ref SimpleCollator.Context ctx)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x060000C1 RID: 193 RVA: 0x000027F0 File Offset: 0x000009F0
+		[Token(Token = "0x60000C1")]
+		[Address(RVA = "0x2ABA8D0", Offset = "0x2AB96D0", VA = "0x182ABA8D0")]
+		private unsafe bool MatchesForwardCore(string s, ref int idx, int end, int ti, byte* sortkey, bool noLv4, SimpleCollator.ExtenderType ext, ref Contraction ct, ref SimpleCollator.Context ctx)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x060000C2 RID: 194 RVA: 0x00002808 File Offset: 0x00000A08
+		[Token(Token = "0x60000C2")]
+		[Address(RVA = "0x2ABAE50", Offset = "0x2AB9C50", VA = "0x182ABAE50")]
+		private unsafe bool MatchesPrimitive(CompareOptions opt, byte* source, int si, SimpleCollator.ExtenderType ext, byte* target, int ti, bool noLv4)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x060000C3 RID: 195 RVA: 0x00002820 File Offset: 0x00000A20
+		[Token(Token = "0x60000C3")]
+		[Address(RVA = "0x2ABA6F0", Offset = "0x2AB94F0", VA = "0x182ABA6F0")]
+		private unsafe bool MatchesBackward(string s, ref int idx, int end, int orgStart, int ti, byte* sortkey, bool noLv4, ref SimpleCollator.Context ctx)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x060000C4 RID: 196 RVA: 0x00002838 File Offset: 0x00000A38
+		[Token(Token = "0x60000C4")]
+		[Address(RVA = "0x2ABA0D0", Offset = "0x2AB8ED0", VA = "0x182ABA0D0")]
+		private unsafe bool MatchesBackwardCore(string s, ref int idx, int end, int orgStart, int ti, byte* sortkey, bool noLv4, SimpleCollator.ExtenderType ext, ref Contraction ct, ref SimpleCollator.Context ctx)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x04000082 RID: 130
+		[Token(Token = "0x4000082")]
+		private static bool QuickCheckDisabled;
+
+		// Token: 0x04000083 RID: 131
+		[Token(Token = "0x4000083")]
+		private static SimpleCollator invariant;
+
+		// Token: 0x04000084 RID: 132
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x4000084")]
+		private readonly TextInfo textInfo;
+
+		// Token: 0x04000085 RID: 133
+		[FieldOffset(Offset = "0x18")]
+		[Token(Token = "0x4000085")]
+		private readonly CodePointIndexer cjkIndexer;
+
+		// Token: 0x04000086 RID: 134
+		[FieldOffset(Offset = "0x20")]
+		[Token(Token = "0x4000086")]
+		private readonly Contraction[] contractions;
+
+		// Token: 0x04000087 RID: 135
+		[FieldOffset(Offset = "0x28")]
+		[Token(Token = "0x4000087")]
+		private readonly Level2Map[] level2Maps;
+
+		// Token: 0x04000088 RID: 136
+		[FieldOffset(Offset = "0x30")]
+		[Token(Token = "0x4000088")]
+		private readonly byte[] unsafeFlags;
+
+		// Token: 0x04000089 RID: 137
+		[FieldOffset(Offset = "0x38")]
+		[Token(Token = "0x4000089")]
+		private unsafe readonly byte* cjkCatTable;
+
+		// Token: 0x0400008A RID: 138
+		[FieldOffset(Offset = "0x40")]
+		[Token(Token = "0x400008A")]
+		private unsafe readonly byte* cjkLv1Table;
+
+		// Token: 0x0400008B RID: 139
+		[FieldOffset(Offset = "0x48")]
+		[Token(Token = "0x400008B")]
+		private unsafe readonly byte* cjkLv2Table;
+
+		// Token: 0x0400008C RID: 140
+		[FieldOffset(Offset = "0x50")]
+		[Token(Token = "0x400008C")]
+		private readonly CodePointIndexer cjkLv2Indexer;
+
+		// Token: 0x0400008D RID: 141
+		[FieldOffset(Offset = "0x58")]
+		[Token(Token = "0x400008D")]
+		private readonly int lcid;
+
+		// Token: 0x0400008E RID: 142
+		[FieldOffset(Offset = "0x5C")]
+		[Token(Token = "0x400008E")]
+		private readonly bool frenchSort;
+
+		// Token: 0x0400008F RID: 143
+		[Token(Token = "0x400008F")]
+		private const int UnsafeFlagLength = default(int);
+
+		// Token: 0x02000029 RID: 41
+		[Token(Token = "0x2000029")]
+		internal struct Context
+		{
+			// Token: 0x060000C6 RID: 198 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x60000C6")]
+			[Address(RVA = "0x2AA82C0", Offset = "0x2AA70C0", VA = "0x182AA82C0")]
+			public unsafe Context(CompareOptions opt, byte* alwaysMatchFlags, byte* neverMatchFlags, byte* buffer1, byte* buffer2, byte* prev1)
+			{
+			}
+
+			// Token: 0x04000090 RID: 144
+			[FieldOffset(Offset = "0x0")]
+			[Token(Token = "0x4000090")]
+			public readonly CompareOptions Option;
+
+			// Token: 0x04000091 RID: 145
+			[FieldOffset(Offset = "0x8")]
+			[Token(Token = "0x4000091")]
+			public unsafe readonly byte* NeverMatchFlags;
+
+			// Token: 0x04000092 RID: 146
+			[FieldOffset(Offset = "0x10")]
+			[Token(Token = "0x4000092")]
+			public unsafe readonly byte* AlwaysMatchFlags;
+
+			// Token: 0x04000093 RID: 147
+			[FieldOffset(Offset = "0x18")]
+			[Token(Token = "0x4000093")]
+			public unsafe byte* Buffer1;
+
+			// Token: 0x04000094 RID: 148
+			[FieldOffset(Offset = "0x20")]
+			[Token(Token = "0x4000094")]
+			public unsafe byte* Buffer2;
+
+			// Token: 0x04000095 RID: 149
+			[FieldOffset(Offset = "0x28")]
+			[Token(Token = "0x4000095")]
+			public int PrevCode;
+
+			// Token: 0x04000096 RID: 150
+			[FieldOffset(Offset = "0x30")]
+			[Token(Token = "0x4000096")]
+			public unsafe byte* PrevSortKey;
+		}
+
+		// Token: 0x0200002A RID: 42
+		[Token(Token = "0x200002A")]
+		private struct PreviousInfo
+		{
+			// Token: 0x060000C7 RID: 199 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x60000C7")]
+			[Address(RVA = "0x2AB2560", Offset = "0x2AB1360", VA = "0x182AB2560")]
+			public PreviousInfo(bool dummy)
+			{
+			}
+
+			// Token: 0x04000097 RID: 151
+			[FieldOffset(Offset = "0x0")]
+			[Token(Token = "0x4000097")]
+			public int Code;
+
+			// Token: 0x04000098 RID: 152
+			[FieldOffset(Offset = "0x8")]
+			[Token(Token = "0x4000098")]
+			public unsafe byte* SortKey;
+		}
+
+		// Token: 0x0200002B RID: 43
+		[Token(Token = "0x200002B")]
+		private struct Escape
+		{
+			// Token: 0x04000099 RID: 153
+			[FieldOffset(Offset = "0x0")]
+			[Token(Token = "0x4000099")]
+			public string Source;
+
+			// Token: 0x0400009A RID: 154
+			[FieldOffset(Offset = "0x8")]
+			[Token(Token = "0x400009A")]
+			public int Index;
+
+			// Token: 0x0400009B RID: 155
+			[FieldOffset(Offset = "0xC")]
+			[Token(Token = "0x400009B")]
+			public int Start;
+
+			// Token: 0x0400009C RID: 156
+			[FieldOffset(Offset = "0x10")]
+			[Token(Token = "0x400009C")]
+			public int End;
+
+			// Token: 0x0400009D RID: 157
+			[FieldOffset(Offset = "0x14")]
+			[Token(Token = "0x400009D")]
+			public int Optional;
+		}
+
+		// Token: 0x0200002C RID: 44
+		[Token(Token = "0x200002C")]
+		private enum ExtenderType
+		{
+			// Token: 0x0400009F RID: 159
+			[Token(Token = "0x400009F")]
+			None,
+			// Token: 0x040000A0 RID: 160
+			[Token(Token = "0x40000A0")]
+			Simple,
+			// Token: 0x040000A1 RID: 161
+			[Token(Token = "0x40000A1")]
+			Voiced,
+			// Token: 0x040000A2 RID: 162
+			[Token(Token = "0x40000A2")]
+			Conditional,
+			// Token: 0x040000A3 RID: 163
+			[Token(Token = "0x40000A3")]
+			Buggy
+		}
+	}
+}

mscorlib/Mono/Globalization/Unicode/SortKeyBuffer.cs

@@ -0,0 +1,201 @@
+using System;
+using System.Globalization;
+using Cpp2IlInjected;
+
+namespace Mono.Globalization.Unicode
+{
+	// Token: 0x0200002D RID: 45
+	[Token(Token = "0x200002D")]
+	internal class SortKeyBuffer
+	{
+		// Token: 0x060000C8 RID: 200 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60000C8")]
+		[Address(RVA = "0x3F5100", Offset = "0x3F3F00", VA = "0x1803F5100")]
+		public SortKeyBuffer(int lcid)
+		{
+		}
+
+		// Token: 0x060000C9 RID: 201 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60000C9")]
+		[Address(RVA = "0x2ABC840", Offset = "0x2ABB640", VA = "0x182ABC840")]
+		public void Reset()
+		{
+		}
+
+		// Token: 0x060000CA RID: 202 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60000CA")]
+		[Address(RVA = "0x2ABC6B0", Offset = "0x2ABB4B0", VA = "0x182ABC6B0")]
+		internal void Initialize(CompareOptions options, int lcid, string s, bool frenchSort)
+		{
+		}
+
+		// Token: 0x060000CB RID: 203 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60000CB")]
+		[Address(RVA = "0x2ABB990", Offset = "0x2ABA790", VA = "0x182ABB990")]
+		internal void AppendCJKExtension(byte lv1msb, byte lv1lsb)
+		{
+		}
+
+		// Token: 0x060000CC RID: 204 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60000CC")]
+		[Address(RVA = "0x2ABBA70", Offset = "0x2ABA870", VA = "0x182ABBA70")]
+		internal void AppendKana(byte category, byte lv1, byte lv2, byte lv3, bool isSmallKana, byte markType, bool isKatakana, bool isHalfWidth)
+		{
+		}
+
+		// Token: 0x060000CD RID: 205 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60000CD")]
+		[Address(RVA = "0x2ABBD30", Offset = "0x2ABAB30", VA = "0x182ABBD30")]
+		internal void AppendNormal(byte category, byte lv1, byte lv2, byte lv3)
+		{
+		}
+
+		// Token: 0x060000CE RID: 206 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60000CE")]
+		[Address(RVA = "0x2ABBB40", Offset = "0x2ABA940", VA = "0x182ABBB40")]
+		private void AppendLevel5(byte category, byte lv1)
+		{
+		}
+
+		// Token: 0x060000CF RID: 207 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60000CF")]
+		[Address(RVA = "0x2ABB8E0", Offset = "0x2ABA6E0", VA = "0x182ABB8E0")]
+		private void AppendBufferPrimitive(byte value, ref byte[] buf, ref int bidx)
+		{
+		}
+
+		// Token: 0x060000D0 RID: 208 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60000D0")]
+		[Address(RVA = "0x2ABBF40", Offset = "0x2ABAD40", VA = "0x182ABBF40")]
+		public SortKey GetResultAndReset()
+		{
+			return null;
+		}
+
+		// Token: 0x060000D1 RID: 209 RVA: 0x00002850 File Offset: 0x00000A50
+		[Token(Token = "0x60000D1")]
+		[Address(RVA = "0x2ABBEE0", Offset = "0x2ABACE0", VA = "0x182ABBEE0")]
+		private int GetOptimizedLength(byte[] data, int len, byte defaultValue)
+		{
+			return 0;
+		}
+
+		// Token: 0x060000D2 RID: 210 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60000D2")]
+		[Address(RVA = "0x2ABBF70", Offset = "0x2ABAD70", VA = "0x182ABBF70")]
+		public SortKey GetResult()
+		{
+			return null;
+		}
+
+		// Token: 0x040000A4 RID: 164
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x40000A4")]
+		private byte[] l1b;
+
+		// Token: 0x040000A5 RID: 165
+		[FieldOffset(Offset = "0x18")]
+		[Token(Token = "0x40000A5")]
+		private byte[] l2b;
+
+		// Token: 0x040000A6 RID: 166
+		[FieldOffset(Offset = "0x20")]
+		[Token(Token = "0x40000A6")]
+		private byte[] l3b;
+
+		// Token: 0x040000A7 RID: 167
+		[FieldOffset(Offset = "0x28")]
+		[Token(Token = "0x40000A7")]
+		private byte[] l4sb;
+
+		// Token: 0x040000A8 RID: 168
+		[FieldOffset(Offset = "0x30")]
+		[Token(Token = "0x40000A8")]
+		private byte[] l4tb;
+
+		// Token: 0x040000A9 RID: 169
+		[FieldOffset(Offset = "0x38")]
+		[Token(Token = "0x40000A9")]
+		private byte[] l4kb;
+
+		// Token: 0x040000AA RID: 170
+		[FieldOffset(Offset = "0x40")]
+		[Token(Token = "0x40000AA")]
+		private byte[] l4wb;
+
+		// Token: 0x040000AB RID: 171
+		[FieldOffset(Offset = "0x48")]
+		[Token(Token = "0x40000AB")]
+		private byte[] l5b;
+
+		// Token: 0x040000AC RID: 172
+		[FieldOffset(Offset = "0x50")]
+		[Token(Token = "0x40000AC")]
+		private string source;
+
+		// Token: 0x040000AD RID: 173
+		[FieldOffset(Offset = "0x58")]
+		[Token(Token = "0x40000AD")]
+		private int l1;
+
+		// Token: 0x040000AE RID: 174
+		[FieldOffset(Offset = "0x5C")]
+		[Token(Token = "0x40000AE")]
+		private int l2;
+
+		// Token: 0x040000AF RID: 175
+		[FieldOffset(Offset = "0x60")]
+		[Token(Token = "0x40000AF")]
+		private int l3;
+
+		// Token: 0x040000B0 RID: 176
+		[FieldOffset(Offset = "0x64")]
+		[Token(Token = "0x40000B0")]
+		private int l4s;
+
+		// Token: 0x040000B1 RID: 177
+		[FieldOffset(Offset = "0x68")]
+		[Token(Token = "0x40000B1")]
+		private int l4t;
+
+		// Token: 0x040000B2 RID: 178
+		[FieldOffset(Offset = "0x6C")]
+		[Token(Token = "0x40000B2")]
+		private int l4k;
+
+		// Token: 0x040000B3 RID: 179
+		[FieldOffset(Offset = "0x70")]
+		[Token(Token = "0x40000B3")]
+		private int l4w;
+
+		// Token: 0x040000B4 RID: 180
+		[FieldOffset(Offset = "0x74")]
+		[Token(Token = "0x40000B4")]
+		private int l5;
+
+		// Token: 0x040000B5 RID: 181
+		[FieldOffset(Offset = "0x78")]
+		[Token(Token = "0x40000B5")]
+		private int lcid;
+
+		// Token: 0x040000B6 RID: 182
+		[FieldOffset(Offset = "0x7C")]
+		[Token(Token = "0x40000B6")]
+		private CompareOptions options;
+
+		// Token: 0x040000B7 RID: 183
+		[FieldOffset(Offset = "0x80")]
+		[Token(Token = "0x40000B7")]
+		private bool processLevel2;
+
+		// Token: 0x040000B8 RID: 184
+		[FieldOffset(Offset = "0x81")]
+		[Token(Token = "0x40000B8")]
+		private bool frenchSort;
+
+		// Token: 0x040000B9 RID: 185
+		[FieldOffset(Offset = "0x82")]
+		[Token(Token = "0x40000B9")]
+		private bool frenchSorted;
+	}
+}

mscorlib/Mono/Globalization/Unicode/TailoringInfo.cs

@@ -0,0 +1,37 @@
+using System;
+using Cpp2IlInjected;
+
+namespace Mono.Globalization.Unicode
+{
+	// Token: 0x02000020 RID: 32
+	[Token(Token = "0x2000020")]
+	internal class TailoringInfo
+	{
+		// Token: 0x06000075 RID: 117 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000075")]
+		[Address(RVA = "0x2ABC880", Offset = "0x2ABB680", VA = "0x182ABC880")]
+		public TailoringInfo(int lcid, int tailoringIndex, int tailoringCount, bool frenchSort)
+		{
+		}
+
+		// Token: 0x04000056 RID: 86
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x4000056")]
+		public readonly int LCID;
+
+		// Token: 0x04000057 RID: 87
+		[FieldOffset(Offset = "0x14")]
+		[Token(Token = "0x4000057")]
+		public readonly int TailoringIndex;
+
+		// Token: 0x04000058 RID: 88
+		[FieldOffset(Offset = "0x18")]
+		[Token(Token = "0x4000058")]
+		public readonly int TailoringCount;
+
+		// Token: 0x04000059 RID: 89
+		[FieldOffset(Offset = "0x1C")]
+		[Token(Token = "0x4000059")]
+		public readonly bool FrenchSort;
+	}
+}

mscorlib/Mono/Math/BigInteger.cs

@@ -0,0 +1,611 @@
+using System;
+using System.Security.Cryptography;
+using Cpp2IlInjected;
+
+namespace Mono.Math
+{
+	// Token: 0x0200004F RID: 79
+	[Token(Token = "0x200004F")]
+	internal class BigInteger
+	{
+		// Token: 0x0600021F RID: 543 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600021F")]
+		[Address(RVA = "0x2AA7590", Offset = "0x2AA6390", VA = "0x182AA7590")]
+		public BigInteger(BigInteger.Sign sign, uint len)
+		{
+		}
+
+		// Token: 0x06000220 RID: 544 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000220")]
+		[Address(RVA = "0x2AA74E0", Offset = "0x2AA62E0", VA = "0x182AA74E0")]
+		public BigInteger(BigInteger bi)
+		{
+		}
+
+		// Token: 0x06000221 RID: 545 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000221")]
+		[Address(RVA = "0x2AA7030", Offset = "0x2AA5E30", VA = "0x182AA7030")]
+		public BigInteger(BigInteger bi, uint len)
+		{
+		}
+
+		// Token: 0x06000222 RID: 546 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000222")]
+		[Address(RVA = "0x2AA7180", Offset = "0x2AA5F80", VA = "0x182AA7180")]
+		public BigInteger(byte[] inData)
+		{
+		}
+
+		// Token: 0x06000223 RID: 547 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000223")]
+		[Address(RVA = "0x2AA7100", Offset = "0x2AA5F00", VA = "0x182AA7100")]
+		public BigInteger(uint ui)
+		{
+		}
+
+		// Token: 0x06000224 RID: 548 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000224")]
+		[Address(RVA = "0x2AA78D0", Offset = "0x2AA66D0", VA = "0x182AA78D0")]
+		public static implicit operator BigInteger(uint value)
+		{
+			return null;
+		}
+
+		// Token: 0x06000225 RID: 549 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000225")]
+		[Address(RVA = "0x2AA7930", Offset = "0x2AA6730", VA = "0x182AA7930")]
+		public static implicit operator BigInteger(int value)
+		{
+			return null;
+		}
+
+		// Token: 0x06000226 RID: 550 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000226")]
+		[Address(RVA = "0x2AA76D0", Offset = "0x2AA64D0", VA = "0x182AA76D0")]
+		public static BigInteger operator +(BigInteger bi1, BigInteger bi2)
+		{
+			return null;
+		}
+
+		// Token: 0x06000227 RID: 551 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000227")]
+		[Address(RVA = "0x2AA7E60", Offset = "0x2AA6C60", VA = "0x182AA7E60")]
+		public static BigInteger operator -(BigInteger bi1, BigInteger bi2)
+		{
+			return null;
+		}
+
+		// Token: 0x06000228 RID: 552 RVA: 0x00002EB0 File Offset: 0x000010B0
+		[Token(Token = "0x6000228")]
+		[Address(RVA = "0x6337F0", Offset = "0x6325F0", VA = "0x1806337F0")]
+		public static uint operator %(BigInteger bi, uint ui)
+		{
+			return 0U;
+		}
+
+		// Token: 0x06000229 RID: 553 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000229")]
+		[Address(RVA = "0x2AA7AA0", Offset = "0x2AA68A0", VA = "0x182AA7AA0")]
+		public static BigInteger operator %(BigInteger bi1, BigInteger bi2)
+		{
+			return null;
+		}
+
+		// Token: 0x0600022A RID: 554 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x600022A")]
+		[Address(RVA = "0x2AA77C0", Offset = "0x2AA65C0", VA = "0x182AA77C0")]
+		public static BigInteger operator /(BigInteger bi1, BigInteger bi2)
+		{
+			return null;
+		}
+
+		// Token: 0x0600022B RID: 555 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x600022B")]
+		[Address(RVA = "0x2AA7AE0", Offset = "0x2AA68E0", VA = "0x182AA7AE0")]
+		public static BigInteger operator *(BigInteger bi1, BigInteger bi2)
+		{
+			return null;
+		}
+
+		// Token: 0x0600022C RID: 556 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x600022C")]
+		[Address(RVA = "0x2AA7D30", Offset = "0x2AA6B30", VA = "0x182AA7D30")]
+		public static BigInteger operator *(BigInteger bi, int i)
+		{
+			return null;
+		}
+
+		// Token: 0x0600022D RID: 557 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x600022D")]
+		[Address(RVA = "0x2AA7A90", Offset = "0x2AA6890", VA = "0x182AA7A90")]
+		public static BigInteger operator <<(BigInteger bi1, int shiftVal)
+		{
+			return null;
+		}
+
+		// Token: 0x0600022E RID: 558 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x600022E")]
+		[Address(RVA = "0x2AA7E50", Offset = "0x2AA6C50", VA = "0x182AA7E50")]
+		public static BigInteger operator >>(BigInteger bi1, int shiftVal)
+		{
+			return null;
+		}
+
+		// Token: 0x1700005A RID: 90
+		// (get) Token: 0x0600022F RID: 559 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x1700005A")]
+		private static RandomNumberGenerator Rng
+		{
+			[Token(Token = "0x600022F")]
+			[Address(RVA = "0x2AA75F0", Offset = "0x2AA63F0", VA = "0x182AA75F0")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x06000230 RID: 560 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000230")]
+		[Address(RVA = "0x2AA6180", Offset = "0x2AA4F80", VA = "0x182AA6180")]
+		public static BigInteger GenerateRandom(int bits, RandomNumberGenerator rng)
+		{
+			return null;
+		}
+
+		// Token: 0x06000231 RID: 561 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000231")]
+		[Address(RVA = "0x2AA6390", Offset = "0x2AA5190", VA = "0x182AA6390")]
+		public static BigInteger GenerateRandom(int bits)
+		{
+			return null;
+		}
+
+		// Token: 0x06000232 RID: 562 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000232")]
+		[Address(RVA = "0x2AA6900", Offset = "0x2AA5700", VA = "0x182AA6900")]
+		public void Randomize(RandomNumberGenerator rng)
+		{
+		}
+
+		// Token: 0x06000233 RID: 563 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000233")]
+		[Address(RVA = "0x2AA6B00", Offset = "0x2AA5900", VA = "0x182AA6B00")]
+		public void Randomize()
+		{
+		}
+
+		// Token: 0x06000234 RID: 564 RVA: 0x00002EC8 File Offset: 0x000010C8
+		[Token(Token = "0x6000234")]
+		[Address(RVA = "0x631CF0", Offset = "0x630AF0", VA = "0x180631CF0")]
+		public int BitCount()
+		{
+			return 0;
+		}
+
+		// Token: 0x06000235 RID: 565 RVA: 0x00002EE0 File Offset: 0x000010E0
+		[Token(Token = "0x6000235")]
+		[Address(RVA = "0x2AA6B60", Offset = "0x2AA5960", VA = "0x182AA6B60")]
+		public bool TestBit(uint bitNum)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x06000236 RID: 566 RVA: 0x00002EF8 File Offset: 0x000010F8
+		[Token(Token = "0x6000236")]
+		[Address(RVA = "0x2AA6BB0", Offset = "0x2AA59B0", VA = "0x182AA6BB0")]
+		public bool TestBit(int bitNum)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x06000237 RID: 567 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000237")]
+		[Address(RVA = "0x6327A0", Offset = "0x6315A0", VA = "0x1806327A0")]
+		public void SetBit(uint bitNum)
+		{
+		}
+
+		// Token: 0x06000238 RID: 568 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000238")]
+		[Address(RVA = "0x632720", Offset = "0x631520", VA = "0x180632720")]
+		public void SetBit(uint bitNum, bool value)
+		{
+		}
+
+		// Token: 0x06000239 RID: 569 RVA: 0x00002F10 File Offset: 0x00001110
+		[Token(Token = "0x6000239")]
+		[Address(RVA = "0x2AA67C0", Offset = "0x2AA55C0", VA = "0x182AA67C0")]
+		public int LowestSetBit()
+		{
+			return 0;
+		}
+
+		// Token: 0x0600023A RID: 570 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x600023A")]
+		[Address(RVA = "0x2AA63F0", Offset = "0x2AA51F0", VA = "0x182AA63F0")]
+		public byte[] GetBytes()
+		{
+			return null;
+		}
+
+		// Token: 0x0600023B RID: 571 RVA: 0x00002F28 File Offset: 0x00001128
+		[Token(Token = "0x600023B")]
+		[Address(RVA = "0x633350", Offset = "0x632150", VA = "0x180633350")]
+		public static bool operator ==(BigInteger bi1, uint ui)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x0600023C RID: 572 RVA: 0x00002F40 File Offset: 0x00001140
+		[Token(Token = "0x600023C")]
+		[Address(RVA = "0x6336C0", Offset = "0x6324C0", VA = "0x1806336C0")]
+		public static bool operator !=(BigInteger bi1, uint ui)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x0600023D RID: 573 RVA: 0x00002F58 File Offset: 0x00001158
+		[Token(Token = "0x600023D")]
+		[Address(RVA = "0x2AA7800", Offset = "0x2AA6600", VA = "0x182AA7800")]
+		public static bool operator ==(BigInteger bi1, BigInteger bi2)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x0600023E RID: 574 RVA: 0x00002F70 File Offset: 0x00001170
+		[Token(Token = "0x600023E")]
+		[Address(RVA = "0x2AA79C0", Offset = "0x2AA67C0", VA = "0x182AA79C0")]
+		public static bool operator !=(BigInteger bi1, BigInteger bi2)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x0600023F RID: 575 RVA: 0x00002F88 File Offset: 0x00001188
+		[Token(Token = "0x600023F")]
+		[Address(RVA = "0x6334E0", Offset = "0x6322E0", VA = "0x1806334E0")]
+		public static bool operator >(BigInteger bi1, BigInteger bi2)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x06000240 RID: 576 RVA: 0x00002FA0 File Offset: 0x000011A0
+		[Token(Token = "0x6000240")]
+		[Address(RVA = "0x633790", Offset = "0x632590", VA = "0x180633790")]
+		public static bool operator <(BigInteger bi1, BigInteger bi2)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x06000241 RID: 577 RVA: 0x00002FB8 File Offset: 0x000011B8
+		[Token(Token = "0x6000241")]
+		[Address(RVA = "0x6334C0", Offset = "0x6322C0", VA = "0x1806334C0")]
+		public static bool operator >=(BigInteger bi1, BigInteger bi2)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x06000242 RID: 578 RVA: 0x00002FD0 File Offset: 0x000011D0
+		[Token(Token = "0x6000242")]
+		[Address(RVA = "0x633770", Offset = "0x632570", VA = "0x180633770")]
+		public static bool operator <=(BigInteger bi1, BigInteger bi2)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x06000243 RID: 579 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000243")]
+		[Address(RVA = "0x2AA6F40", Offset = "0x2AA5D40", VA = "0x182AA6F40")]
+		public string ToString(uint radix)
+		{
+			return null;
+		}
+
+		// Token: 0x06000244 RID: 580 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000244")]
+		[Address(RVA = "0x2AA6C60", Offset = "0x2AA5A60", VA = "0x182AA6C60")]
+		public string ToString(uint radix, string characterSet)
+		{
+			return null;
+		}
+
+		// Token: 0x06000245 RID: 581 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000245")]
+		[Address(RVA = "0x6326C0", Offset = "0x6314C0", VA = "0x1806326C0")]
+		private void Normalize()
+		{
+		}
+
+		// Token: 0x06000246 RID: 582 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000246")]
+		[Address(RVA = "0x2AA5F40", Offset = "0x2AA4D40", VA = "0x182AA5F40")]
+		public void Clear()
+		{
+		}
+
+		// Token: 0x06000247 RID: 583 RVA: 0x00002FE8 File Offset: 0x000011E8
+		[Token(Token = "0x6000247")]
+		[Address(RVA = "0x632410", Offset = "0x631210", VA = "0x180632410", Slot = "2")]
+		public override int GetHashCode()
+		{
+			return 0;
+		}
+
+		// Token: 0x06000248 RID: 584 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000248")]
+		[Address(RVA = "0x2AA6F90", Offset = "0x2AA5D90", VA = "0x182AA6F90", Slot = "3")]
+		public override string ToString()
+		{
+			return null;
+		}
+
+		// Token: 0x06000249 RID: 585 RVA: 0x00003000 File Offset: 0x00001200
+		[Token(Token = "0x6000249")]
+		[Address(RVA = "0x2AA5FA0", Offset = "0x2AA4DA0", VA = "0x182AA5FA0", Slot = "0")]
+		public override bool Equals(object o)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x0600024A RID: 586 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x600024A")]
+		[Address(RVA = "0x2AA6860", Offset = "0x2AA5660", VA = "0x182AA6860")]
+		public BigInteger ModInverse(BigInteger modulus)
+		{
+			return null;
+		}
+
+		// Token: 0x0600024B RID: 587 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x600024B")]
+		[Address(RVA = "0x2AA6870", Offset = "0x2AA5670", VA = "0x182AA6870")]
+		public BigInteger ModPow(BigInteger exp, BigInteger n)
+		{
+			return null;
+		}
+
+		// Token: 0x0600024C RID: 588 RVA: 0x00003018 File Offset: 0x00001218
+		[Token(Token = "0x600024C")]
+		[Address(RVA = "0x2AA6530", Offset = "0x2AA5330", VA = "0x182AA6530")]
+		public bool IsProbablePrime()
+		{
+			return default(bool);
+		}
+
+		// Token: 0x0600024D RID: 589 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x600024D")]
+		[Address(RVA = "0x2AA6110", Offset = "0x2AA4F10", VA = "0x182AA6110")]
+		public static BigInteger GeneratePseudoPrime(int bits)
+		{
+			return null;
+		}
+
+		// Token: 0x0600024E RID: 590 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600024E")]
+		[Address(RVA = "0x632460", Offset = "0x631260", VA = "0x180632460")]
+		public void Incr2()
+		{
+		}
+
+		// Token: 0x0400014F RID: 335
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x400014F")]
+		private uint length;
+
+		// Token: 0x04000150 RID: 336
+		[FieldOffset(Offset = "0x18")]
+		[Token(Token = "0x4000150")]
+		private uint[] data;
+
+		// Token: 0x04000151 RID: 337
+		[Token(Token = "0x4000151")]
+		internal static readonly uint[] smallPrimes;
+
+		// Token: 0x04000152 RID: 338
+		[Token(Token = "0x4000152")]
+		private static RandomNumberGenerator rng;
+
+		// Token: 0x02000050 RID: 80
+		[Token(Token = "0x2000050")]
+		public enum Sign
+		{
+			// Token: 0x04000154 RID: 340
+			[Token(Token = "0x4000154")]
+			Negative = -1,
+			// Token: 0x04000155 RID: 341
+			[Token(Token = "0x4000155")]
+			Zero,
+			// Token: 0x04000156 RID: 342
+			[Token(Token = "0x4000156")]
+			Positive
+		}
+
+		// Token: 0x02000051 RID: 81
+		[Token(Token = "0x2000051")]
+		internal sealed class ModulusRing
+		{
+			// Token: 0x06000250 RID: 592 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6000250")]
+			[Address(RVA = "0x2AB2020", Offset = "0x2AB0E20", VA = "0x182AB2020")]
+			public ModulusRing(BigInteger modulus)
+			{
+			}
+
+			// Token: 0x06000251 RID: 593 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6000251")]
+			[Address(RVA = "0x2AB15B0", Offset = "0x2AB03B0", VA = "0x182AB15B0")]
+			public void BarrettReduction(BigInteger x)
+			{
+			}
+
+			// Token: 0x06000252 RID: 594 RVA: 0x00002082 File Offset: 0x00000282
+			[Token(Token = "0x6000252")]
+			[Address(RVA = "0x2AB1BC0", Offset = "0x2AB09C0", VA = "0x182AB1BC0")]
+			public BigInteger Multiply(BigInteger a, BigInteger b)
+			{
+				return null;
+			}
+
+			// Token: 0x06000253 RID: 595 RVA: 0x00002082 File Offset: 0x00000282
+			[Token(Token = "0x6000253")]
+			[Address(RVA = "0x2AB1970", Offset = "0x2AB0770", VA = "0x182AB1970")]
+			public BigInteger Difference(BigInteger a, BigInteger b)
+			{
+				return null;
+			}
+
+			// Token: 0x06000254 RID: 596 RVA: 0x00002082 File Offset: 0x00000282
+			[Token(Token = "0x6000254")]
+			[Address(RVA = "0x2AB1EC0", Offset = "0x2AB0CC0", VA = "0x182AB1EC0")]
+			public BigInteger Pow(BigInteger a, BigInteger k)
+			{
+				return null;
+			}
+
+			// Token: 0x06000255 RID: 597 RVA: 0x00002082 File Offset: 0x00000282
+			[Token(Token = "0x6000255")]
+			[Address(RVA = "0x2AB1E40", Offset = "0x2AB0C40", VA = "0x182AB1E40")]
+			public BigInteger Pow(uint b, BigInteger exp)
+			{
+				return null;
+			}
+
+			// Token: 0x04000157 RID: 343
+			[FieldOffset(Offset = "0x10")]
+			[Token(Token = "0x4000157")]
+			private BigInteger mod;
+
+			// Token: 0x04000158 RID: 344
+			[FieldOffset(Offset = "0x18")]
+			[Token(Token = "0x4000158")]
+			private BigInteger constant;
+		}
+
+		// Token: 0x02000052 RID: 82
+		[Token(Token = "0x2000052")]
+		private sealed class Kernel
+		{
+			// Token: 0x06000256 RID: 598 RVA: 0x00002082 File Offset: 0x00000282
+			[Token(Token = "0x6000256")]
+			[Address(RVA = "0x2AA8BB0", Offset = "0x2AA79B0", VA = "0x182AA8BB0")]
+			public static BigInteger AddSameSign(BigInteger bi1, BigInteger bi2)
+			{
+				return null;
+			}
+
+			// Token: 0x06000257 RID: 599 RVA: 0x00002082 File Offset: 0x00000282
+			[Token(Token = "0x6000257")]
+			[Address(RVA = "0x2AA9880", Offset = "0x2AA8680", VA = "0x182AA9880")]
+			public static BigInteger Subtract(BigInteger big, BigInteger small)
+			{
+				return null;
+			}
+
+			// Token: 0x06000258 RID: 600 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6000258")]
+			[Address(RVA = "0x6389F0", Offset = "0x6377F0", VA = "0x1806389F0")]
+			public static void MinusEq(BigInteger big, BigInteger small)
+			{
+			}
+
+			// Token: 0x06000259 RID: 601 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6000259")]
+			[Address(RVA = "0x638E00", Offset = "0x637C00", VA = "0x180638E00")]
+			public static void PlusEq(BigInteger bi1, BigInteger bi2)
+			{
+			}
+
+			// Token: 0x0600025A RID: 602 RVA: 0x00003030 File Offset: 0x00001230
+			[Token(Token = "0x600025A")]
+			[Address(RVA = "0x638250", Offset = "0x637050", VA = "0x180638250")]
+			public static BigInteger.Sign Compare(BigInteger bi1, BigInteger bi2)
+			{
+				return BigInteger.Sign.Zero;
+			}
+
+			// Token: 0x0600025B RID: 603 RVA: 0x00003048 File Offset: 0x00001248
+			[Token(Token = "0x600025B")]
+			[Address(RVA = "0x6392C0", Offset = "0x6380C0", VA = "0x1806392C0")]
+			public static uint SingleByteDivideInPlace(BigInteger n, uint d)
+			{
+				return 0U;
+			}
+
+			// Token: 0x0600025C RID: 604 RVA: 0x00003060 File Offset: 0x00001260
+			[Token(Token = "0x600025C")]
+			[Address(RVA = "0x6337F0", Offset = "0x6325F0", VA = "0x1806337F0")]
+			public static uint DwordMod(BigInteger n, uint d)
+			{
+				return 0U;
+			}
+
+			// Token: 0x0600025D RID: 605 RVA: 0x00002082 File Offset: 0x00000282
+			[Token(Token = "0x600025D")]
+			[Address(RVA = "0x2AA8E80", Offset = "0x2AA7C80", VA = "0x182AA8E80")]
+			public static BigInteger[] DwordDivMod(BigInteger n, uint d)
+			{
+				return null;
+			}
+
+			// Token: 0x0600025E RID: 606 RVA: 0x00002082 File Offset: 0x00000282
+			[Token(Token = "0x600025E")]
+			[Address(RVA = "0x2AAA520", Offset = "0x2AA9320", VA = "0x182AAA520")]
+			public static BigInteger[] multiByteDivide(BigInteger bi1, BigInteger bi2)
+			{
+				return null;
+			}
+
+			// Token: 0x0600025F RID: 607 RVA: 0x00002082 File Offset: 0x00000282
+			[Token(Token = "0x600025F")]
+			[Address(RVA = "0x2AA9180", Offset = "0x2AA7F80", VA = "0x182AA9180")]
+			public static BigInteger LeftShift(BigInteger bi, int n)
+			{
+				return null;
+			}
+
+			// Token: 0x06000260 RID: 608 RVA: 0x00002082 File Offset: 0x00000282
+			[Token(Token = "0x6000260")]
+			[Address(RVA = "0x2AA9620", Offset = "0x2AA8420", VA = "0x182AA9620")]
+			public static BigInteger RightShift(BigInteger bi, int n)
+			{
+				return null;
+			}
+
+			// Token: 0x06000261 RID: 609 RVA: 0x00002082 File Offset: 0x00000282
+			[Token(Token = "0x6000261")]
+			[Address(RVA = "0x2AA9480", Offset = "0x2AA8280", VA = "0x182AA9480")]
+			public static BigInteger MultiplyByDword(BigInteger n, uint f)
+			{
+				return null;
+			}
+
+			// Token: 0x06000262 RID: 610 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6000262")]
+			[Address(RVA = "0x638CB0", Offset = "0x637AB0", VA = "0x180638CB0")]
+			public static void Multiply(uint[] x, uint xOffset, uint xLen, uint[] y, uint yOffset, uint yLen, uint[] d, uint dOffset)
+			{
+			}
+
+			// Token: 0x06000263 RID: 611 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6000263")]
+			[Address(RVA = "0x638B70", Offset = "0x637970", VA = "0x180638B70")]
+			public static void MultiplyMod2p32pmod(uint[] x, int xOffset, int xLen, uint[] y, int yOffest, int yLen, uint[] d, int dOffset, int mod)
+			{
+			}
+
+			// Token: 0x06000264 RID: 612 RVA: 0x00003078 File Offset: 0x00001278
+			[Token(Token = "0x6000264")]
+			[Address(RVA = "0x2AA9B20", Offset = "0x2AA8920", VA = "0x182AA9B20")]
+			public static uint modInverse(BigInteger bi, uint modulus)
+			{
+				return 0U;
+			}
+
+			// Token: 0x06000265 RID: 613 RVA: 0x00002082 File Offset: 0x00000282
+			[Token(Token = "0x6000265")]
+			[Address(RVA = "0x2AA9C50", Offset = "0x2AA8A50", VA = "0x182AA9C50")]
+			public static BigInteger modInverse(BigInteger bi, BigInteger modulus)
+			{
+				return null;
+			}
+		}
+	}
+}

mscorlib/Mono/Math/Prime/ConfidenceFactor.cs

@@ -0,0 +1,29 @@
+using System;
+using Cpp2IlInjected;
+
+namespace Mono.Math.Prime
+{
+	// Token: 0x02000053 RID: 83
+	[Token(Token = "0x2000053")]
+	internal enum ConfidenceFactor
+	{
+		// Token: 0x0400015A RID: 346
+		[Token(Token = "0x400015A")]
+		ExtraLow,
+		// Token: 0x0400015B RID: 347
+		[Token(Token = "0x400015B")]
+		Low,
+		// Token: 0x0400015C RID: 348
+		[Token(Token = "0x400015C")]
+		Medium,
+		// Token: 0x0400015D RID: 349
+		[Token(Token = "0x400015D")]
+		High,
+		// Token: 0x0400015E RID: 350
+		[Token(Token = "0x400015E")]
+		ExtraHigh,
+		// Token: 0x0400015F RID: 351
+		[Token(Token = "0x400015F")]
+		Provable
+	}
+}

mscorlib/Mono/Math/Prime/Generator/PrimeGeneratorBase.cs

@@ -0,0 +1,61 @@
+using System;
+using Cpp2IlInjected;
+
+namespace Mono.Math.Prime.Generator
+{
+	// Token: 0x02000056 RID: 86
+	[Token(Token = "0x2000056")]
+	internal abstract class PrimeGeneratorBase
+	{
+		// Token: 0x1700005B RID: 91
+		// (get) Token: 0x0600026E RID: 622 RVA: 0x000030F0 File Offset: 0x000012F0
+		[Token(Token = "0x1700005B")]
+		public virtual ConfidenceFactor Confidence
+		{
+			[Token(Token = "0x600026E")]
+			[Address(RVA = "0x460DB0", Offset = "0x45FBB0", VA = "0x180460DB0", Slot = "4")]
+			get
+			{
+				return ConfidenceFactor.ExtraLow;
+			}
+		}
+
+		// Token: 0x1700005C RID: 92
+		// (get) Token: 0x0600026F RID: 623 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x1700005C")]
+		public virtual PrimalityTest PrimalityTest
+		{
+			[Token(Token = "0x600026F")]
+			[Address(RVA = "0x2AB2E70", Offset = "0x2AB1C70", VA = "0x182AB2E70", Slot = "5")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x1700005D RID: 93
+		// (get) Token: 0x06000270 RID: 624 RVA: 0x00003108 File Offset: 0x00001308
+		[Token(Token = "0x1700005D")]
+		public virtual int TrialDivisionBounds
+		{
+			[Token(Token = "0x6000270")]
+			[Address(RVA = "0x6450A0", Offset = "0x643EA0", VA = "0x1806450A0", Slot = "6")]
+			get
+			{
+				return 0;
+			}
+		}
+
+		// Token: 0x06000271 RID: 625
+		[Token(Token = "0x6000271")]
+		[Address(Slot = "7")]
+		public abstract BigInteger GenerateNewPrime(int bits);
+
+		// Token: 0x06000272 RID: 626 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000272")]
+		[Address(RVA = "0x3F5100", Offset = "0x3F3F00", VA = "0x1803F5100")]
+		protected PrimeGeneratorBase()
+		{
+		}
+	}
+}

mscorlib/Mono/Math/Prime/Generator/SequentialSearchPrimeGeneratorBase.cs

@@ -0,0 +1,49 @@
+using System;
+using Cpp2IlInjected;
+
+namespace Mono.Math.Prime.Generator
+{
+	// Token: 0x02000057 RID: 87
+	[Token(Token = "0x2000057")]
+	internal class SequentialSearchPrimeGeneratorBase : PrimeGeneratorBase
+	{
+		// Token: 0x06000273 RID: 627 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000273")]
+		[Address(RVA = "0x2AB5960", Offset = "0x2AB4760", VA = "0x182AB5960", Slot = "8")]
+		protected virtual BigInteger GenerateSearchBase(int bits, object context)
+		{
+			return null;
+		}
+
+		// Token: 0x06000274 RID: 628 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000274")]
+		[Address(RVA = "0x4DBEF0", Offset = "0x4DACF0", VA = "0x1804DBEF0", Slot = "7")]
+		public override BigInteger GenerateNewPrime(int bits)
+		{
+			return null;
+		}
+
+		// Token: 0x06000275 RID: 629 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000275")]
+		[Address(RVA = "0x2AB5560", Offset = "0x2AB4360", VA = "0x182AB5560", Slot = "9")]
+		public virtual BigInteger GenerateNewPrime(int bits, object context)
+		{
+			return null;
+		}
+
+		// Token: 0x06000276 RID: 630 RVA: 0x00003120 File Offset: 0x00001320
+		[Token(Token = "0x6000276")]
+		[Address(RVA = "0x460D40", Offset = "0x45FB40", VA = "0x180460D40", Slot = "10")]
+		protected virtual bool IsPrimeAcceptable(BigInteger bi, object context)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x06000277 RID: 631 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000277")]
+		[Address(RVA = "0x3F5100", Offset = "0x3F3F00", VA = "0x1803F5100")]
+		public SequentialSearchPrimeGeneratorBase()
+		{
+		}
+	}
+}

mscorlib/Mono/Math/Prime/PrimalityTest.cs

@@ -0,0 +1,10 @@
+using System;
+using Cpp2IlInjected;
+
+namespace Mono.Math.Prime
+{
+	// Token: 0x02000054 RID: 84
+	// (Invoke) Token: 0x06000267 RID: 615
+	[Token(Token = "0x2000054")]
+	internal delegate bool PrimalityTest(BigInteger bi, ConfidenceFactor confidence);
+}

mscorlib/Mono/Math/Prime/PrimalityTests.cs

@@ -0,0 +1,42 @@
+using System;
+using Cpp2IlInjected;
+
+namespace Mono.Math.Prime
+{
+	// Token: 0x02000055 RID: 85
+	[Token(Token = "0x2000055")]
+	internal sealed class PrimalityTests
+	{
+		// Token: 0x0600026A RID: 618 RVA: 0x00003090 File Offset: 0x00001290
+		[Token(Token = "0x600026A")]
+		[Address(RVA = "0x2AB2600", Offset = "0x2AB1400", VA = "0x182AB2600")]
+		private static int GetSPPRounds(BigInteger bi, ConfidenceFactor confidence)
+		{
+			return 0;
+		}
+
+		// Token: 0x0600026B RID: 619 RVA: 0x000030A8 File Offset: 0x000012A8
+		[Token(Token = "0x600026B")]
+		[Address(RVA = "0x2AB2E20", Offset = "0x2AB1C20", VA = "0x182AB2E20")]
+		public static bool Test(BigInteger n, ConfidenceFactor confidence)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x0600026C RID: 620 RVA: 0x000030C0 File Offset: 0x000012C0
+		[Token(Token = "0x600026C")]
+		[Address(RVA = "0x2AB27C0", Offset = "0x2AB15C0", VA = "0x182AB27C0")]
+		public static bool RabinMillerTest(BigInteger n, ConfidenceFactor confidence)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x0600026D RID: 621 RVA: 0x000030D8 File Offset: 0x000012D8
+		[Token(Token = "0x600026D")]
+		[Address(RVA = "0x2AB2BB0", Offset = "0x2AB19B0", VA = "0x182AB2BB0")]
+		public static bool SmallPrimeSppTest(BigInteger bi, ConfidenceFactor confidence)
+		{
+			return default(bool);
+		}
+	}
+}

mscorlib/Mono/MonoAssemblyName.cs

@@ -0,0 +1,89 @@
+using System;
+using System.Runtime.CompilerServices;
+using Cpp2IlInjected;
+
+namespace Mono
+{
+	// Token: 0x02000014 RID: 20
+	[Token(Token = "0x2000014")]
+	internal struct MonoAssemblyName
+	{
+		// Token: 0x04000029 RID: 41
+		[FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x4000029")]
+		internal IntPtr name;
+
+		// Token: 0x0400002A RID: 42
+		[FieldOffset(Offset = "0x8")]
+		[Token(Token = "0x400002A")]
+		internal IntPtr culture;
+
+		// Token: 0x0400002B RID: 43
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x400002B")]
+		internal IntPtr hash_value;
+
+		// Token: 0x0400002C RID: 44
+		[FieldOffset(Offset = "0x18")]
+		[Token(Token = "0x400002C")]
+		internal IntPtr public_key;
+
+		// Token: 0x0400002D RID: 45
+		[FieldOffset(Offset = "0x20")]
+		[Token(Token = "0x400002D")]
+		[FixedBuffer(typeof(byte), 17)]
+		internal MonoAssemblyName.<public_key_token>e__FixedBuffer public_key_token;
+
+		// Token: 0x0400002E RID: 46
+		[FieldOffset(Offset = "0x34")]
+		[Token(Token = "0x400002E")]
+		internal uint hash_alg;
+
+		// Token: 0x0400002F RID: 47
+		[FieldOffset(Offset = "0x38")]
+		[Token(Token = "0x400002F")]
+		internal uint hash_len;
+
+		// Token: 0x04000030 RID: 48
+		[FieldOffset(Offset = "0x3C")]
+		[Token(Token = "0x4000030")]
+		internal uint flags;
+
+		// Token: 0x04000031 RID: 49
+		[FieldOffset(Offset = "0x40")]
+		[Token(Token = "0x4000031")]
+		internal ushort major;
+
+		// Token: 0x04000032 RID: 50
+		[FieldOffset(Offset = "0x42")]
+		[Token(Token = "0x4000032")]
+		internal ushort minor;
+
+		// Token: 0x04000033 RID: 51
+		[FieldOffset(Offset = "0x44")]
+		[Token(Token = "0x4000033")]
+		internal ushort build;
+
+		// Token: 0x04000034 RID: 52
+		[FieldOffset(Offset = "0x46")]
+		[Token(Token = "0x4000034")]
+		internal ushort revision;
+
+		// Token: 0x04000035 RID: 53
+		[FieldOffset(Offset = "0x48")]
+		[Token(Token = "0x4000035")]
+		internal ushort arch;
+
+		// Token: 0x02000015 RID: 21
+		[Token(Token = "0x2000015")]
+		[CompilerGenerated]
+		[UnsafeValueType]
+		public struct <public_key_token>e__FixedBuffer
+		{
+			// Token: 0x04000036 RID: 54
+			[FieldOffset(Offset = "0x0")]
+			[Token(Token = "0x4000036")]
+			public byte FixedElementField;
+		}
+	}
+}

mscorlib/Mono/Runtime.cs

@@ -0,0 +1,62 @@
+using System;
+using Cpp2IlInjected;
+
+namespace Mono
+{
+	// Token: 0x02000005 RID: 5
+	[Token(Token = "0x2000005")]
+	public static class Runtime
+	{
+		// Token: 0x06000009 RID: 9 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000009")]
+		[Address(RVA = "0x2AB52D0", Offset = "0x2AB40D0", VA = "0x182AB52D0")]
+		private static void mono_runtime_install_handlers()
+		{
+		}
+
+		// Token: 0x0600000A RID: 10 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600000A")]
+		[Address(RVA = "0x2AB52D0", Offset = "0x2AB40D0", VA = "0x182AB52D0")]
+		public static void InstallSignalHandlers()
+		{
+		}
+
+		// Token: 0x0600000B RID: 11 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600000B")]
+		[Address(RVA = "0x2AB52E0", Offset = "0x2AB40E0", VA = "0x182AB52E0")]
+		private static void mono_runtime_cleanup_handlers()
+		{
+		}
+
+		// Token: 0x0600000C RID: 12 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600000C")]
+		[Address(RVA = "0x2AB52E0", Offset = "0x2AB40E0", VA = "0x182AB52E0")]
+		public static void RemoveSignalHandlers()
+		{
+		}
+
+		// Token: 0x0600000D RID: 13 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x600000D")]
+		[Address(RVA = "0x2AB52C0", Offset = "0x2AB40C0", VA = "0x182AB52C0")]
+		public static string GetDisplayName()
+		{
+			return null;
+		}
+
+		// Token: 0x0600000E RID: 14 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x600000E")]
+		[Address(RVA = "0x450D90", Offset = "0x44FB90", VA = "0x180450D90")]
+		private static string GetNativeStackTrace(Exception exception)
+		{
+			return null;
+		}
+
+		// Token: 0x0600000F RID: 15 RVA: 0x00002088 File Offset: 0x00000288
+		[Token(Token = "0x600000F")]
+		[Address(RVA = "0x460D40", Offset = "0x45FB40", VA = "0x180460D40")]
+		public static bool SetGCAllowSynchronousMajor(bool flag)
+		{
+			return default(bool);
+		}
+	}
+}

mscorlib/Mono/RuntimeClassHandle.cs

@@ -0,0 +1,74 @@
+using System;
+using Cpp2IlInjected;
+
+namespace Mono
+{
+	// Token: 0x02000006 RID: 6
+	[Token(Token = "0x2000006")]
+	internal struct RuntimeClassHandle
+	{
+		// Token: 0x06000010 RID: 16 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000010")]
+		[Address(RVA = "0x461A30", Offset = "0x460830", VA = "0x180461A30")]
+		internal unsafe RuntimeClassHandle(RuntimeStructs.MonoClass* value)
+		{
+		}
+
+		// Token: 0x06000011 RID: 17 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000011")]
+		[Address(RVA = "0x2AB4F20", Offset = "0x2AB3D20", VA = "0x182AB4F20")]
+		internal RuntimeClassHandle(IntPtr ptr)
+		{
+		}
+
+		// Token: 0x17000001 RID: 1
+		// (get) Token: 0x06000012 RID: 18 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x17000001")]
+		internal unsafe RuntimeStructs.MonoClass* Value
+		{
+			[Token(Token = "0x6000012")]
+			[Address(RVA = "0x41D090", Offset = "0x41BE90", VA = "0x18041D090")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x06000013 RID: 19 RVA: 0x000020A0 File Offset: 0x000002A0
+		[Token(Token = "0x6000013")]
+		[Address(RVA = "0x2AB4DD0", Offset = "0x2AB3BD0", VA = "0x182AB4DD0", Slot = "0")]
+		public override bool Equals(object obj)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x06000014 RID: 20 RVA: 0x000020B8 File Offset: 0x000002B8
+		[Token(Token = "0x6000014")]
+		[Address(RVA = "0x2AB4ED0", Offset = "0x2AB3CD0", VA = "0x182AB4ED0", Slot = "2")]
+		public override int GetHashCode()
+		{
+			return 0;
+		}
+
+		// Token: 0x06000015 RID: 21 RVA: 0x000020D0 File Offset: 0x000002D0
+		[Token(Token = "0x6000015")]
+		[Address(RVA = "0x2AB4F00", Offset = "0x2AB3D00", VA = "0x182AB4F00")]
+		internal unsafe static IntPtr GetTypeFromClass(RuntimeStructs.MonoClass* klass)
+		{
+			return 0;
+		}
+
+		// Token: 0x06000016 RID: 22 RVA: 0x000020E8 File Offset: 0x000002E8
+		[Token(Token = "0x6000016")]
+		[Address(RVA = "0x2AB4F10", Offset = "0x2AB3D10", VA = "0x182AB4F10")]
+		internal RuntimeTypeHandle GetTypeHandle()
+		{
+			return default(RuntimeTypeHandle);
+		}
+
+		// Token: 0x04000002 RID: 2
+		[FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x4000002")]
+		private unsafe RuntimeStructs.MonoClass* value;
+	}
+}

mscorlib/Mono/RuntimeEventHandle.cs

@@ -0,0 +1,51 @@
+using System;
+using Cpp2IlInjected;
+
+namespace Mono
+{
+	// Token: 0x02000009 RID: 9
+	[Token(Token = "0x2000009")]
+	internal struct RuntimeEventHandle
+	{
+		// Token: 0x0600001D RID: 29 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600001D")]
+		[Address(RVA = "0x461A30", Offset = "0x460830", VA = "0x180461A30")]
+		internal RuntimeEventHandle(IntPtr v)
+		{
+		}
+
+		// Token: 0x17000005 RID: 5
+		// (get) Token: 0x0600001E RID: 30 RVA: 0x00002148 File Offset: 0x00000348
+		[Token(Token = "0x17000005")]
+		public IntPtr Value
+		{
+			[Token(Token = "0x600001E")]
+			[Address(RVA = "0x41D090", Offset = "0x41BE90", VA = "0x18041D090")]
+			get
+			{
+				return 0;
+			}
+		}
+
+		// Token: 0x0600001F RID: 31 RVA: 0x00002160 File Offset: 0x00000360
+		[Token(Token = "0x600001F")]
+		[Address(RVA = "0x2AB4F40", Offset = "0x2AB3D40", VA = "0x182AB4F40", Slot = "0")]
+		public override bool Equals(object obj)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x06000020 RID: 32 RVA: 0x00002178 File Offset: 0x00000378
+		[Token(Token = "0x6000020")]
+		[Address(RVA = "0x164A950", Offset = "0x1649750", VA = "0x18164A950", Slot = "2")]
+		public override int GetHashCode()
+		{
+			return 0;
+		}
+
+		// Token: 0x04000005 RID: 5
+		[FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x4000005")]
+		private IntPtr value;
+	}
+}

mscorlib/Mono/RuntimeGPtrArrayHandle.cs

@@ -0,0 +1,69 @@
+using System;
+using Cpp2IlInjected;
+
+namespace Mono
+{
+	// Token: 0x0200000B RID: 11
+	[Token(Token = "0x200000B")]
+	internal struct RuntimeGPtrArrayHandle
+	{
+		// Token: 0x06000025 RID: 37 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000025")]
+		[Address(RVA = "0x2AB4F20", Offset = "0x2AB3D20", VA = "0x182AB4F20")]
+		internal RuntimeGPtrArrayHandle(IntPtr ptr)
+		{
+		}
+
+		// Token: 0x17000007 RID: 7
+		// (get) Token: 0x06000026 RID: 38 RVA: 0x000021D8 File Offset: 0x000003D8
+		[Token(Token = "0x17000007")]
+		internal int Length
+		{
+			[Token(Token = "0x6000026")]
+			[Address(RVA = "0x2AB5120", Offset = "0x2AB3F20", VA = "0x182AB5120")]
+			get
+			{
+				return 0;
+			}
+		}
+
+		// Token: 0x17000008 RID: 8
+		[Token(Token = "0x17000008")]
+		internal IntPtr this[int i]
+		{
+			[Token(Token = "0x6000027")]
+			[Address(RVA = "0x2AB5110", Offset = "0x2AB3F10", VA = "0x182AB5110")]
+			get
+			{
+				return 0;
+			}
+		}
+
+		// Token: 0x06000028 RID: 40 RVA: 0x00002208 File Offset: 0x00000408
+		[Token(Token = "0x6000028")]
+		[Address(RVA = "0x2AB5080", Offset = "0x2AB3E80", VA = "0x182AB5080")]
+		internal IntPtr Lookup(int i)
+		{
+			return 0;
+		}
+
+		// Token: 0x06000029 RID: 41 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000029")]
+		[Address(RVA = "0x2AB5070", Offset = "0x2AB3E70", VA = "0x182AB5070")]
+		private unsafe static void GPtrArrayFree(RuntimeStructs.GPtrArray* value)
+		{
+		}
+
+		// Token: 0x0600002A RID: 42 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600002A")]
+		[Address(RVA = "0x2AB5050", Offset = "0x2AB3E50", VA = "0x182AB5050")]
+		internal static void DestroyAndFree(ref RuntimeGPtrArrayHandle h)
+		{
+		}
+
+		// Token: 0x04000007 RID: 7
+		[FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x4000007")]
+		private unsafe RuntimeStructs.GPtrArray* value;
+	}
+}

mscorlib/Mono/RuntimeGenericParamInfoHandle.cs

@@ -0,0 +1,65 @@
+using System;
+using System.Reflection;
+using Cpp2IlInjected;
+
+namespace Mono
+{
+	// Token: 0x02000008 RID: 8
+	[Token(Token = "0x2000008")]
+	internal struct RuntimeGenericParamInfoHandle
+	{
+		// Token: 0x06000018 RID: 24 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000018")]
+		[Address(RVA = "0x2AB4F20", Offset = "0x2AB3D20", VA = "0x182AB4F20")]
+		internal RuntimeGenericParamInfoHandle(IntPtr ptr)
+		{
+		}
+
+		// Token: 0x17000003 RID: 3
+		// (get) Token: 0x06000019 RID: 25 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x17000003")]
+		internal Type[] Constraints
+		{
+			[Token(Token = "0x6000019")]
+			[Address(RVA = "0x2AB52B0", Offset = "0x2AB40B0", VA = "0x182AB52B0")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x17000004 RID: 4
+		// (get) Token: 0x0600001A RID: 26 RVA: 0x00002118 File Offset: 0x00000318
+		[Token(Token = "0x17000004")]
+		internal GenericParameterAttributes Attributes
+		{
+			[Token(Token = "0x600001A")]
+			[Address(RVA = "0x2AB5290", Offset = "0x2AB4090", VA = "0x182AB5290")]
+			get
+			{
+				return GenericParameterAttributes.None;
+			}
+		}
+
+		// Token: 0x0600001B RID: 27 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x600001B")]
+		[Address(RVA = "0x2AB5170", Offset = "0x2AB3F70", VA = "0x182AB5170")]
+		private Type[] GetConstraints()
+		{
+			return null;
+		}
+
+		// Token: 0x0600001C RID: 28 RVA: 0x00002130 File Offset: 0x00000330
+		[Token(Token = "0x600001C")]
+		[Address(RVA = "0x2AB5140", Offset = "0x2AB3F40", VA = "0x182AB5140")]
+		private int GetConstraintsCount()
+		{
+			return 0;
+		}
+
+		// Token: 0x04000004 RID: 4
+		[FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x4000004")]
+		private unsafe RuntimeStructs.GenericParamInfo* value;
+	}
+}

mscorlib/Mono/RuntimeMarshal.cs

@@ -0,0 +1,57 @@
+using System;
+using Cpp2IlInjected;
+
+namespace Mono
+{
+	// Token: 0x0200000C RID: 12
+	[Token(Token = "0x200000C")]
+	internal static class RuntimeMarshal
+	{
+		// Token: 0x0600002B RID: 43 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x600002B")]
+		[Address(RVA = "0x2B32B50", Offset = "0x2B31950", VA = "0x182B32B50")]
+		internal static string PtrToUtf8String(IntPtr ptr)
+		{
+			return null;
+		}
+
+		// Token: 0x0600002C RID: 44 RVA: 0x00002220 File Offset: 0x00000420
+		[Token(Token = "0x600002C")]
+		[Address(RVA = "0x2B32B00", Offset = "0x2B31900", VA = "0x182B32B00")]
+		internal static SafeStringMarshal MarshalString(string str)
+		{
+			return default(SafeStringMarshal);
+		}
+
+		// Token: 0x0600002D RID: 45 RVA: 0x00002238 File Offset: 0x00000438
+		[Token(Token = "0x600002D")]
+		[Address(RVA = "0x2B32A70", Offset = "0x2B31870", VA = "0x182B32A70")]
+		private static int DecodeBlobSize(IntPtr in_ptr, out IntPtr out_ptr)
+		{
+			return 0;
+		}
+
+		// Token: 0x0600002E RID: 46 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x600002E")]
+		[Address(RVA = "0x2B32980", Offset = "0x2B31780", VA = "0x182B32980")]
+		internal static byte[] DecodeBlobArray(IntPtr ptr)
+		{
+			return null;
+		}
+
+		// Token: 0x0600002F RID: 47 RVA: 0x00002250 File Offset: 0x00000450
+		[Token(Token = "0x600002F")]
+		[Address(RVA = "0x2B32960", Offset = "0x2B31760", VA = "0x182B32960")]
+		internal static int AsciHexDigitValue(int c)
+		{
+			return 0;
+		}
+
+		// Token: 0x06000030 RID: 48 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000030")]
+		[Address(RVA = "0x2B32AF0", Offset = "0x2B318F0", VA = "0x182B32AF0")]
+		internal static void FreeAssemblyName(ref MonoAssemblyName name, bool freeStruct)
+		{
+		}
+	}
+}

mscorlib/Mono/RuntimePropertyHandle.cs

@@ -0,0 +1,51 @@
+using System;
+using Cpp2IlInjected;
+
+namespace Mono
+{
+	// Token: 0x0200000A RID: 10
+	[Token(Token = "0x200000A")]
+	internal struct RuntimePropertyHandle
+	{
+		// Token: 0x06000021 RID: 33 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000021")]
+		[Address(RVA = "0x461A30", Offset = "0x460830", VA = "0x180461A30")]
+		internal RuntimePropertyHandle(IntPtr v)
+		{
+		}
+
+		// Token: 0x17000006 RID: 6
+		// (get) Token: 0x06000022 RID: 34 RVA: 0x00002190 File Offset: 0x00000390
+		[Token(Token = "0x17000006")]
+		public IntPtr Value
+		{
+			[Token(Token = "0x6000022")]
+			[Address(RVA = "0x41D090", Offset = "0x41BE90", VA = "0x18041D090")]
+			get
+			{
+				return 0;
+			}
+		}
+
+		// Token: 0x06000023 RID: 35 RVA: 0x000021A8 File Offset: 0x000003A8
+		[Token(Token = "0x6000023")]
+		[Address(RVA = "0x2B32C70", Offset = "0x2B31A70", VA = "0x182B32C70", Slot = "0")]
+		public override bool Equals(object obj)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x06000024 RID: 36 RVA: 0x000021C0 File Offset: 0x000003C0
+		[Token(Token = "0x6000024")]
+		[Address(RVA = "0x164A950", Offset = "0x1649750", VA = "0x18164A950", Slot = "2")]
+		public override int GetHashCode()
+		{
+			return 0;
+		}
+
+		// Token: 0x04000006 RID: 6
+		[FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x4000006")]
+		private IntPtr value;
+	}
+}

mscorlib/Mono/RuntimeRemoteClassHandle.cs

@@ -0,0 +1,28 @@
+using System;
+using Cpp2IlInjected;
+
+namespace Mono
+{
+	// Token: 0x02000007 RID: 7
+	[Token(Token = "0x2000007")]
+	internal struct RuntimeRemoteClassHandle
+	{
+		// Token: 0x17000002 RID: 2
+		// (get) Token: 0x06000017 RID: 23 RVA: 0x00002100 File Offset: 0x00000300
+		[Token(Token = "0x17000002")]
+		internal RuntimeClassHandle ProxyClass
+		{
+			[Token(Token = "0x6000017")]
+			[Address(RVA = "0x4C4F20", Offset = "0x4C3D20", VA = "0x1804C4F20")]
+			get
+			{
+				return default(RuntimeClassHandle);
+			}
+		}
+
+		// Token: 0x04000003 RID: 3
+		[FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x4000003")]
+		private unsafe RuntimeStructs.RemoteClass* value;
+	}
+}

mscorlib/Mono/RuntimeStructs.cs

@@ -0,0 +1,206 @@
+using System;
+using Cpp2IlInjected;
+
+namespace Mono
+{
+	// Token: 0x0200000D RID: 13
+	[Token(Token = "0x200000D")]
+	internal static class RuntimeStructs
+	{
+		// Token: 0x0200000E RID: 14
+		[Token(Token = "0x200000E")]
+		internal struct RemoteClass
+		{
+			// Token: 0x04000008 RID: 8
+			[FieldOffset(Offset = "0x0")]
+			[Token(Token = "0x4000008")]
+			internal IntPtr default_vtable;
+
+			// Token: 0x04000009 RID: 9
+			[FieldOffset(Offset = "0x8")]
+			[Token(Token = "0x4000009")]
+			internal IntPtr xdomain_vtable;
+
+			// Token: 0x0400000A RID: 10
+			[FieldOffset(Offset = "0x10")]
+			[Token(Token = "0x400000A")]
+			internal unsafe RuntimeStructs.MonoClass* proxy_class;
+
+			// Token: 0x0400000B RID: 11
+			[FieldOffset(Offset = "0x18")]
+			[Token(Token = "0x400000B")]
+			internal IntPtr proxy_class_name;
+
+			// Token: 0x0400000C RID: 12
+			[FieldOffset(Offset = "0x20")]
+			[Token(Token = "0x400000C")]
+			internal uint interface_count;
+		}
+
+		// Token: 0x0200000F RID: 15
+		[Token(Token = "0x200000F")]
+		internal struct MonoClass
+		{
+		}
+
+		// Token: 0x02000010 RID: 16
+		[Token(Token = "0x2000010")]
+		internal struct GenericParamInfo
+		{
+			// Token: 0x0400000D RID: 13
+			[FieldOffset(Offset = "0x0")]
+			[Token(Token = "0x400000D")]
+			internal unsafe RuntimeStructs.MonoClass* pklass;
+
+			// Token: 0x0400000E RID: 14
+			[FieldOffset(Offset = "0x8")]
+			[Token(Token = "0x400000E")]
+			internal IntPtr name;
+
+			// Token: 0x0400000F RID: 15
+			[FieldOffset(Offset = "0x10")]
+			[Token(Token = "0x400000F")]
+			internal ushort flags;
+
+			// Token: 0x04000010 RID: 16
+			[FieldOffset(Offset = "0x14")]
+			[Token(Token = "0x4000010")]
+			internal uint token;
+
+			// Token: 0x04000011 RID: 17
+			[FieldOffset(Offset = "0x18")]
+			[Token(Token = "0x4000011")]
+			internal unsafe RuntimeStructs.MonoClass** constraints;
+		}
+
+		// Token: 0x02000011 RID: 17
+		[Token(Token = "0x2000011")]
+		internal struct GPtrArray
+		{
+			// Token: 0x04000012 RID: 18
+			[FieldOffset(Offset = "0x0")]
+			[Token(Token = "0x4000012")]
+			internal unsafe IntPtr* data;
+
+			// Token: 0x04000013 RID: 19
+			[FieldOffset(Offset = "0x8")]
+			[Token(Token = "0x4000013")]
+			internal int len;
+		}
+
+		// Token: 0x02000012 RID: 18
+		[Token(Token = "0x2000012")]
+		private struct HandleStackMark
+		{
+			// Token: 0x04000014 RID: 20
+			[FieldOffset(Offset = "0x0")]
+			[Token(Token = "0x4000014")]
+			private int size;
+
+			// Token: 0x04000015 RID: 21
+			[FieldOffset(Offset = "0x4")]
+			[Token(Token = "0x4000015")]
+			private int interior_size;
+
+			// Token: 0x04000016 RID: 22
+			[FieldOffset(Offset = "0x8")]
+			[Token(Token = "0x4000016")]
+			private IntPtr chunk;
+		}
+
+		// Token: 0x02000013 RID: 19
+		[Token(Token = "0x2000013")]
+		private struct MonoError
+		{
+			// Token: 0x04000017 RID: 23
+			[FieldOffset(Offset = "0x0")]
+			[Token(Token = "0x4000017")]
+			private ushort error_code;
+
+			// Token: 0x04000018 RID: 24
+			[FieldOffset(Offset = "0x2")]
+			[Token(Token = "0x4000018")]
+			private ushort hidden_0;
+
+			// Token: 0x04000019 RID: 25
+			[FieldOffset(Offset = "0x8")]
+			[Token(Token = "0x4000019")]
+			private IntPtr hidden_1;
+
+			// Token: 0x0400001A RID: 26
+			[FieldOffset(Offset = "0x10")]
+			[Token(Token = "0x400001A")]
+			private IntPtr hidden_2;
+
+			// Token: 0x0400001B RID: 27
+			[FieldOffset(Offset = "0x18")]
+			[Token(Token = "0x400001B")]
+			private IntPtr hidden_3;
+
+			// Token: 0x0400001C RID: 28
+			[FieldOffset(Offset = "0x20")]
+			[Token(Token = "0x400001C")]
+			private IntPtr hidden_4;
+
+			// Token: 0x0400001D RID: 29
+			[FieldOffset(Offset = "0x28")]
+			[Token(Token = "0x400001D")]
+			private IntPtr hidden_5;
+
+			// Token: 0x0400001E RID: 30
+			[FieldOffset(Offset = "0x30")]
+			[Token(Token = "0x400001E")]
+			private IntPtr hidden_6;
+
+			// Token: 0x0400001F RID: 31
+			[FieldOffset(Offset = "0x38")]
+			[Token(Token = "0x400001F")]
+			private IntPtr hidden_7;
+
+			// Token: 0x04000020 RID: 32
+			[FieldOffset(Offset = "0x40")]
+			[Token(Token = "0x4000020")]
+			private IntPtr hidden_8;
+
+			// Token: 0x04000021 RID: 33
+			[FieldOffset(Offset = "0x48")]
+			[Token(Token = "0x4000021")]
+			private IntPtr hidden_11;
+
+			// Token: 0x04000022 RID: 34
+			[FieldOffset(Offset = "0x50")]
+			[Token(Token = "0x4000022")]
+			private IntPtr hidden_12;
+
+			// Token: 0x04000023 RID: 35
+			[FieldOffset(Offset = "0x58")]
+			[Token(Token = "0x4000023")]
+			private IntPtr hidden_13;
+
+			// Token: 0x04000024 RID: 36
+			[FieldOffset(Offset = "0x60")]
+			[Token(Token = "0x4000024")]
+			private IntPtr hidden_14;
+
+			// Token: 0x04000025 RID: 37
+			[FieldOffset(Offset = "0x68")]
+			[Token(Token = "0x4000025")]
+			private IntPtr hidden_15;
+
+			// Token: 0x04000026 RID: 38
+			[FieldOffset(Offset = "0x70")]
+			[Token(Token = "0x4000026")]
+			private IntPtr hidden_16;
+
+			// Token: 0x04000027 RID: 39
+			[FieldOffset(Offset = "0x78")]
+			[Token(Token = "0x4000027")]
+			private IntPtr hidden_17;
+
+			// Token: 0x04000028 RID: 40
+			[FieldOffset(Offset = "0x80")]
+			[Token(Token = "0x4000028")]
+			private IntPtr hidden_18;
+		}
+	}
+}

mscorlib/Mono/SafeGPtrArrayHandle.cs

@@ -0,0 +1,54 @@
+using System;
+using Cpp2IlInjected;
+
+namespace Mono
+{
+	// Token: 0x02000016 RID: 22
+	[Token(Token = "0x2000016")]
+	internal struct SafeGPtrArrayHandle : IDisposable
+	{
+		// Token: 0x06000031 RID: 49 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000031")]
+		[Address(RVA = "0x2B32D90", Offset = "0x2B31B90", VA = "0x182B32D90")]
+		internal SafeGPtrArrayHandle(IntPtr ptr)
+		{
+		}
+
+		// Token: 0x06000032 RID: 50 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000032")]
+		[Address(RVA = "0x2B32D80", Offset = "0x2B31B80", VA = "0x182B32D80", Slot = "4")]
+		public void Dispose()
+		{
+		}
+
+		// Token: 0x17000009 RID: 9
+		// (get) Token: 0x06000033 RID: 51 RVA: 0x00002268 File Offset: 0x00000468
+		[Token(Token = "0x17000009")]
+		internal int Length
+		{
+			[Token(Token = "0x6000033")]
+			[Address(RVA = "0x2B32DD0", Offset = "0x2B31BD0", VA = "0x182B32DD0")]
+			get
+			{
+				return 0;
+			}
+		}
+
+		// Token: 0x1700000A RID: 10
+		[Token(Token = "0x1700000A")]
+		internal IntPtr this[int i]
+		{
+			[Token(Token = "0x6000034")]
+			[Address(RVA = "0x2B32DC0", Offset = "0x2B31BC0", VA = "0x182B32DC0")]
+			get
+			{
+				return 0;
+			}
+		}
+
+		// Token: 0x04000037 RID: 55
+		[FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x4000037")]
+		private RuntimeGPtrArrayHandle handle;
+	}
+}

mscorlib/Mono/SafeStringMarshal.cs

@@ -0,0 +1,62 @@
+using System;
+using Cpp2IlInjected;
+
+namespace Mono
+{
+	// Token: 0x02000017 RID: 23
+	[Token(Token = "0x2000017")]
+	internal struct SafeStringMarshal : IDisposable
+	{
+		// Token: 0x06000035 RID: 53 RVA: 0x00002298 File Offset: 0x00000498
+		[Token(Token = "0x6000035")]
+		[Address(RVA = "0x2B32E40", Offset = "0x2B31C40", VA = "0x182B32E40")]
+		public static IntPtr StringToUtf8(string str)
+		{
+			return 0;
+		}
+
+		// Token: 0x06000036 RID: 54 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000036")]
+		[Address(RVA = "0x2B32E30", Offset = "0x2B31C30", VA = "0x182B32E30")]
+		public static void GFree(IntPtr ptr)
+		{
+		}
+
+		// Token: 0x06000037 RID: 55 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000037")]
+		[Address(RVA = "0x2B32E50", Offset = "0x2B31C50", VA = "0x182B32E50")]
+		public SafeStringMarshal(string str)
+		{
+		}
+
+		// Token: 0x1700000B RID: 11
+		// (get) Token: 0x06000038 RID: 56 RVA: 0x000022B0 File Offset: 0x000004B0
+		[Token(Token = "0x1700000B")]
+		public IntPtr Value
+		{
+			[Token(Token = "0x6000038")]
+			[Address(RVA = "0x2B32EB0", Offset = "0x2B31CB0", VA = "0x182B32EB0")]
+			get
+			{
+				return 0;
+			}
+		}
+
+		// Token: 0x06000039 RID: 57 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000039")]
+		[Address(RVA = "0x2B32DE0", Offset = "0x2B31BE0", VA = "0x182B32DE0", Slot = "4")]
+		public void Dispose()
+		{
+		}
+
+		// Token: 0x04000038 RID: 56
+		[FieldOffset(Offset = "0x0")]
+		[Token(Token = "0x4000038")]
+		private readonly string str;
+
+		// Token: 0x04000039 RID: 57
+		[FieldOffset(Offset = "0x8")]
+		[Token(Token = "0x4000039")]
+		private IntPtr marshaled_string;
+	}
+}

mscorlib/Mono/Security/ASN1.cs

@@ -0,0 +1,179 @@
+using System;
+using System.Collections;
+using Cpp2IlInjected;
+
+namespace Mono.Security
+{
+	// Token: 0x0200002E RID: 46
+	[Token(Token = "0x200002E")]
+	internal class ASN1
+	{
+		// Token: 0x060000D3 RID: 211 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60000D3")]
+		[Address(RVA = "0x631710", Offset = "0x630510", VA = "0x180631710")]
+		public ASN1(byte tag)
+		{
+		}
+
+		// Token: 0x060000D4 RID: 212 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60000D4")]
+		[Address(RVA = "0x631740", Offset = "0x630540", VA = "0x180631740")]
+		public ASN1(byte tag, byte[] data)
+		{
+		}
+
+		// Token: 0x060000D5 RID: 213 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60000D5")]
+		[Address(RVA = "0x2B1F520", Offset = "0x2B1E320", VA = "0x182B1F520")]
+		public ASN1(byte[] data)
+		{
+		}
+
+		// Token: 0x17000013 RID: 19
+		// (get) Token: 0x060000D6 RID: 214 RVA: 0x00002868 File Offset: 0x00000A68
+		[Token(Token = "0x17000013")]
+		public int Count
+		{
+			[Token(Token = "0x60000D6")]
+			[Address(RVA = "0x631910", Offset = "0x630710", VA = "0x180631910")]
+			get
+			{
+				return 0;
+			}
+		}
+
+		// Token: 0x17000014 RID: 20
+		// (get) Token: 0x060000D7 RID: 215 RVA: 0x00002880 File Offset: 0x00000A80
+		[Token(Token = "0x17000014")]
+		public byte Tag
+		{
+			[Token(Token = "0x60000D7")]
+			[Address(RVA = "0x42D5E0", Offset = "0x42C3E0", VA = "0x18042D5E0")]
+			get
+			{
+				return 0;
+			}
+		}
+
+		// Token: 0x17000015 RID: 21
+		// (get) Token: 0x060000D8 RID: 216 RVA: 0x00002898 File Offset: 0x00000A98
+		[Token(Token = "0x17000015")]
+		public int Length
+		{
+			[Token(Token = "0x60000D8")]
+			[Address(RVA = "0x631A20", Offset = "0x630820", VA = "0x180631A20")]
+			get
+			{
+				return 0;
+			}
+		}
+
+		// Token: 0x17000016 RID: 22
+		// (get) Token: 0x060000D9 RID: 217 RVA: 0x00002082 File Offset: 0x00000282
+		// (set) Token: 0x060000DA RID: 218 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x17000016")]
+		public byte[] Value
+		{
+			[Token(Token = "0x60000D9")]
+			[Address(RVA = "0x2B1F7A0", Offset = "0x2B1E5A0", VA = "0x182B1F7A0")]
+			get
+			{
+				return null;
+			}
+			[Token(Token = "0x60000DA")]
+			[Address(RVA = "0x2B1F840", Offset = "0x2B1E640", VA = "0x182B1F840")]
+			set
+			{
+			}
+		}
+
+		// Token: 0x060000DB RID: 219 RVA: 0x000028B0 File Offset: 0x00000AB0
+		[Token(Token = "0x60000DB")]
+		[Address(RVA = "0x6307F0", Offset = "0x62F5F0", VA = "0x1806307F0")]
+		private bool CompareArray(byte[] array1, byte[] array2)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x060000DC RID: 220 RVA: 0x000028C8 File Offset: 0x00000AC8
+		[Token(Token = "0x60000DC")]
+		[Address(RVA = "0x630890", Offset = "0x62F690", VA = "0x180630890")]
+		public bool CompareValue(byte[] value)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x060000DD RID: 221 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60000DD")]
+		[Address(RVA = "0x2B1E6A0", Offset = "0x2B1D4A0", VA = "0x182B1E6A0")]
+		public ASN1 Add(ASN1 asn1)
+		{
+			return null;
+		}
+
+		// Token: 0x060000DE RID: 222 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60000DE")]
+		[Address(RVA = "0x2B1EB60", Offset = "0x2B1D960", VA = "0x182B1EB60", Slot = "4")]
+		public virtual byte[] GetBytes()
+		{
+			return null;
+		}
+
+		// Token: 0x060000DF RID: 223 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60000DF")]
+		[Address(RVA = "0x2B1E860", Offset = "0x2B1D660", VA = "0x182B1E860")]
+		protected void Decode(byte[] asn1, ref int anPos, int anLength)
+		{
+		}
+
+		// Token: 0x060000E0 RID: 224 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60000E0")]
+		[Address(RVA = "0x2B1E730", Offset = "0x2B1D530", VA = "0x182B1E730")]
+		protected void DecodeTLV(byte[] asn1, ref int pos, out byte tag, out int length, out byte[] content)
+		{
+		}
+
+		// Token: 0x17000017 RID: 23
+		[Token(Token = "0x17000017")]
+		public ASN1 this[int index]
+		{
+			[Token(Token = "0x60000E1")]
+			[Address(RVA = "0x2B1F6B0", Offset = "0x2B1E4B0", VA = "0x182B1F6B0")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x060000E2 RID: 226 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60000E2")]
+		[Address(RVA = "0x2B1EA50", Offset = "0x2B1D850", VA = "0x182B1EA50")]
+		public ASN1 Element(int index, byte anTag)
+		{
+			return null;
+		}
+
+		// Token: 0x060000E3 RID: 227 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60000E3")]
+		[Address(RVA = "0x2B1F250", Offset = "0x2B1E050", VA = "0x182B1F250", Slot = "3")]
+		public override string ToString()
+		{
+			return null;
+		}
+
+		// Token: 0x040000BA RID: 186
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x40000BA")]
+		private byte m_nTag;
+
+		// Token: 0x040000BB RID: 187
+		[FieldOffset(Offset = "0x18")]
+		[Token(Token = "0x40000BB")]
+		private byte[] m_aValue;
+
+		// Token: 0x040000BC RID: 188
+		[FieldOffset(Offset = "0x20")]
+		[Token(Token = "0x40000BC")]
+		private ArrayList elist;
+	}
+}

mscorlib/Mono/Security/ASN1Convert.cs

@@ -0,0 +1,50 @@
+using System;
+using Cpp2IlInjected;
+
+namespace Mono.Security
+{
+	// Token: 0x0200002F RID: 47
+	[Token(Token = "0x200002F")]
+	internal static class ASN1Convert
+	{
+		// Token: 0x060000E4 RID: 228 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60000E4")]
+		[Address(RVA = "0x2B1DA90", Offset = "0x2B1C890", VA = "0x182B1DA90")]
+		public static ASN1 FromInt32(int value)
+		{
+			return null;
+		}
+
+		// Token: 0x060000E5 RID: 229 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60000E5")]
+		[Address(RVA = "0x2B1DCD0", Offset = "0x2B1CAD0", VA = "0x182B1DCD0")]
+		public static ASN1 FromOid(string oid)
+		{
+			return null;
+		}
+
+		// Token: 0x060000E6 RID: 230 RVA: 0x000028E0 File Offset: 0x00000AE0
+		[Token(Token = "0x60000E6")]
+		[Address(RVA = "0x2B1E240", Offset = "0x2B1D040", VA = "0x182B1E240")]
+		public static int ToInt32(ASN1 asn1)
+		{
+			return 0;
+		}
+
+		// Token: 0x060000E7 RID: 231 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60000E7")]
+		[Address(RVA = "0x2B1E3E0", Offset = "0x2B1D1E0", VA = "0x182B1E3E0")]
+		public static string ToOid(ASN1 asn1)
+		{
+			return null;
+		}
+
+		// Token: 0x060000E8 RID: 232 RVA: 0x000028F8 File Offset: 0x00000AF8
+		[Token(Token = "0x60000E8")]
+		[Address(RVA = "0x2B1DD70", Offset = "0x2B1CB70", VA = "0x182B1DD70")]
+		public static DateTime ToDateTime(ASN1 time)
+		{
+			return default(DateTime);
+		}
+	}
+}

mscorlib/Mono/Security/BitConverterLE.cs

@@ -0,0 +1,80 @@
+using System;
+using Cpp2IlInjected;
+
+namespace Mono.Security
+{
+	// Token: 0x02000030 RID: 48
+	[Token(Token = "0x2000030")]
+	internal sealed class BitConverterLE
+	{
+		// Token: 0x060000E9 RID: 233 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60000E9")]
+		[Address(RVA = "0x2B1F920", Offset = "0x2B1E720", VA = "0x182B1F920")]
+		private unsafe static byte[] GetUIntBytes(byte* bytes)
+		{
+			return null;
+		}
+
+		// Token: 0x060000EA RID: 234 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60000EA")]
+		[Address(RVA = "0x2B1FA90", Offset = "0x2B1E890", VA = "0x182B1FA90")]
+		private unsafe static byte[] GetULongBytes(byte* bytes)
+		{
+			return null;
+		}
+
+		// Token: 0x060000EB RID: 235 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60000EB")]
+		[Address(RVA = "0x2B1F8E0", Offset = "0x2B1E6E0", VA = "0x182B1F8E0")]
+		internal static byte[] GetBytes(int value)
+		{
+			return null;
+		}
+
+		// Token: 0x060000EC RID: 236 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60000EC")]
+		[Address(RVA = "0x2B1F900", Offset = "0x2B1E700", VA = "0x182B1F900")]
+		internal static byte[] GetBytes(float value)
+		{
+			return null;
+		}
+
+		// Token: 0x060000ED RID: 237 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60000ED")]
+		[Address(RVA = "0x2B1F8C0", Offset = "0x2B1E6C0", VA = "0x182B1F8C0")]
+		internal static byte[] GetBytes(double value)
+		{
+			return null;
+		}
+
+		// Token: 0x060000EE RID: 238 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60000EE")]
+		[Address(RVA = "0x2B1FE60", Offset = "0x2B1EC60", VA = "0x182B1FE60")]
+		private unsafe static void UIntFromBytes(byte* dst, byte[] src, int startIndex)
+		{
+		}
+
+		// Token: 0x060000EF RID: 239 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60000EF")]
+		[Address(RVA = "0x2B20020", Offset = "0x2B1EE20", VA = "0x182B20020")]
+		private unsafe static void ULongFromBytes(byte* dst, byte[] src, int startIndex)
+		{
+		}
+
+		// Token: 0x060000F0 RID: 240 RVA: 0x00002910 File Offset: 0x00000B10
+		[Token(Token = "0x60000F0")]
+		[Address(RVA = "0x2B1FE30", Offset = "0x2B1EC30", VA = "0x182B1FE30")]
+		internal static float ToSingle(byte[] value, int startIndex)
+		{
+			return 0f;
+		}
+
+		// Token: 0x060000F1 RID: 241 RVA: 0x00002928 File Offset: 0x00000B28
+		[Token(Token = "0x60000F1")]
+		[Address(RVA = "0x2B1FD30", Offset = "0x2B1EB30", VA = "0x182B1FD30")]
+		internal static double ToDouble(byte[] value, int startIndex)
+		{
+			return 0.0;
+		}
+	}
+}

mscorlib/Mono/Security/Cryptography/ARC4Managed.cs

@@ -0,0 +1,196 @@
+using System;
+using System.Security.Cryptography;
+using Cpp2IlInjected;
+
+namespace Mono.Security.Cryptography
+{
+	// Token: 0x0200003D RID: 61
+	[Token(Token = "0x200003D")]
+	internal class ARC4Managed : RC4, ICryptoTransform, IDisposable
+	{
+		// Token: 0x06000157 RID: 343 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000157")]
+		[Address(RVA = "0x2B1D700", Offset = "0x2B1C500", VA = "0x182B1D700")]
+		public ARC4Managed()
+		{
+		}
+
+		// Token: 0x06000158 RID: 344 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000158")]
+		[Address(RVA = "0x2B1CFC0", Offset = "0x2B1BDC0", VA = "0x182B1CFC0", Slot = "1")]
+		protected override void Finalize()
+		{
+		}
+
+		// Token: 0x06000159 RID: 345 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000159")]
+		[Address(RVA = "0x2B1CF10", Offset = "0x2B1BD10", VA = "0x182B1CF10", Slot = "5")]
+		protected override void Dispose(bool disposing)
+		{
+		}
+
+		// Token: 0x17000036 RID: 54
+		// (get) Token: 0x0600015A RID: 346 RVA: 0x00002082 File Offset: 0x00000282
+		// (set) Token: 0x0600015B RID: 347 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x17000036")]
+		public override byte[] Key
+		{
+			[Token(Token = "0x600015A")]
+			[Address(RVA = "0x2B1D7F0", Offset = "0x2B1C5F0", VA = "0x182B1D7F0", Slot = "12")]
+			get
+			{
+				return null;
+			}
+			[Token(Token = "0x600015B")]
+			[Address(RVA = "0x2B1D890", Offset = "0x2B1C690", VA = "0x182B1D890", Slot = "13")]
+			set
+			{
+			}
+		}
+
+		// Token: 0x17000037 RID: 55
+		// (get) Token: 0x0600015C RID: 348 RVA: 0x00002A60 File Offset: 0x00000C60
+		[Token(Token = "0x17000037")]
+		public bool CanReuseTransform
+		{
+			[Token(Token = "0x600015C")]
+			[Address(RVA = "0x403930", Offset = "0x402730", VA = "0x180403930", Slot = "31")]
+			get
+			{
+				return default(bool);
+			}
+		}
+
+		// Token: 0x0600015D RID: 349 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x600015D")]
+		[Address(RVA = "0x2B1CEE0", Offset = "0x2B1BCE0", VA = "0x182B1CEE0", Slot = "23")]
+		public override ICryptoTransform CreateEncryptor(byte[] rgbKey, byte[] rgvIV)
+		{
+			return null;
+		}
+
+		// Token: 0x0600015E RID: 350 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x600015E")]
+		[Address(RVA = "0x2B1CEA0", Offset = "0x2B1BCA0", VA = "0x182B1CEA0", Slot = "25")]
+		public override ICryptoTransform CreateDecryptor(byte[] rgbKey, byte[] rgvIV)
+		{
+			return null;
+		}
+
+		// Token: 0x0600015F RID: 351 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600015F")]
+		[Address(RVA = "0x2B1D040", Offset = "0x2B1BE40", VA = "0x182B1D040", Slot = "27")]
+		public override void GenerateIV()
+		{
+		}
+
+		// Token: 0x06000160 RID: 352 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000160")]
+		[Address(RVA = "0x2B1D090", Offset = "0x2B1BE90", VA = "0x182B1D090", Slot = "26")]
+		public override void GenerateKey()
+		{
+		}
+
+		// Token: 0x17000038 RID: 56
+		// (get) Token: 0x06000161 RID: 353 RVA: 0x00002A78 File Offset: 0x00000C78
+		[Token(Token = "0x17000038")]
+		public bool CanTransformMultipleBlocks
+		{
+			[Token(Token = "0x6000161")]
+			[Address(RVA = "0x460D40", Offset = "0x45FB40", VA = "0x180460D40", Slot = "30")]
+			get
+			{
+				return default(bool);
+			}
+		}
+
+		// Token: 0x17000039 RID: 57
+		// (get) Token: 0x06000162 RID: 354 RVA: 0x00002A90 File Offset: 0x00000C90
+		[Token(Token = "0x17000039")]
+		public int InputBlockSize
+		{
+			[Token(Token = "0x6000162")]
+			[Address(RVA = "0x4100E0", Offset = "0x40EEE0", VA = "0x1804100E0", Slot = "28")]
+			get
+			{
+				return 0;
+			}
+		}
+
+		// Token: 0x1700003A RID: 58
+		// (get) Token: 0x06000163 RID: 355 RVA: 0x00002AA8 File Offset: 0x00000CA8
+		[Token(Token = "0x1700003A")]
+		public int OutputBlockSize
+		{
+			[Token(Token = "0x6000163")]
+			[Address(RVA = "0x4100E0", Offset = "0x40EEE0", VA = "0x1804100E0", Slot = "29")]
+			get
+			{
+				return 0;
+			}
+		}
+
+		// Token: 0x06000164 RID: 356 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000164")]
+		[Address(RVA = "0x2B1D380", Offset = "0x2B1C180", VA = "0x182B1D380")]
+		private void KeySetup(byte[] key)
+		{
+		}
+
+		// Token: 0x06000165 RID: 357 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000165")]
+		[Address(RVA = "0x2B1CD50", Offset = "0x2B1BB50", VA = "0x182B1CD50")]
+		private void CheckInput(byte[] inputBuffer, int inputOffset, int inputCount)
+		{
+		}
+
+		// Token: 0x06000166 RID: 358 RVA: 0x00002AC0 File Offset: 0x00000CC0
+		[Token(Token = "0x6000166")]
+		[Address(RVA = "0x2B1D4E0", Offset = "0x2B1C2E0", VA = "0x182B1D4E0", Slot = "32")]
+		public int TransformBlock(byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset)
+		{
+			return 0;
+		}
+
+		// Token: 0x06000167 RID: 359 RVA: 0x00002AD8 File Offset: 0x00000CD8
+		[Token(Token = "0x6000167")]
+		[Address(RVA = "0x2B1D160", Offset = "0x2B1BF60", VA = "0x182B1D160")]
+		private int InternalTransformBlock(byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset)
+		{
+			return 0;
+		}
+
+		// Token: 0x06000168 RID: 360 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000168")]
+		[Address(RVA = "0x2B1D640", Offset = "0x2B1C440", VA = "0x182B1D640", Slot = "33")]
+		public byte[] TransformFinalBlock(byte[] inputBuffer, int inputOffset, int inputCount)
+		{
+			return null;
+		}
+
+		// Token: 0x04000101 RID: 257
+		[FieldOffset(Offset = "0x48")]
+		[Token(Token = "0x4000101")]
+		private byte[] key;
+
+		// Token: 0x04000102 RID: 258
+		[FieldOffset(Offset = "0x50")]
+		[Token(Token = "0x4000102")]
+		private byte[] state;
+
+		// Token: 0x04000103 RID: 259
+		[FieldOffset(Offset = "0x58")]
+		[Token(Token = "0x4000103")]
+		private byte x;
+
+		// Token: 0x04000104 RID: 260
+		[FieldOffset(Offset = "0x59")]
+		[Token(Token = "0x4000104")]
+		private byte y;
+
+		// Token: 0x04000105 RID: 261
+		[FieldOffset(Offset = "0x5A")]
+		[Token(Token = "0x4000105")]
+		private bool m_disposed;
+	}
+}

mscorlib/Mono/Security/Cryptography/CryptoConvert.cs

@@ -0,0 +1,139 @@
+using System;
+using System.Security.Cryptography;
+using Cpp2IlInjected;
+
+namespace Mono.Security.Cryptography
+{
+	// Token: 0x0200003E RID: 62
+	[Token(Token = "0x200003E")]
+	internal sealed class CryptoConvert
+	{
+		// Token: 0x06000169 RID: 361 RVA: 0x00002AF0 File Offset: 0x00000CF0
+		[Token(Token = "0x6000169")]
+		[Address(RVA = "0x2B22BF0", Offset = "0x2B219F0", VA = "0x182B22BF0")]
+		private static int ToInt32LE(byte[] bytes, int offset)
+		{
+			return 0;
+		}
+
+		// Token: 0x0600016A RID: 362 RVA: 0x00002B08 File Offset: 0x00000D08
+		[Token(Token = "0x600016A")]
+		[Address(RVA = "0x2B22BF0", Offset = "0x2B219F0", VA = "0x182B22BF0")]
+		private static uint ToUInt32LE(byte[] bytes, int offset)
+		{
+			return 0U;
+		}
+
+		// Token: 0x0600016B RID: 363 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x600016B")]
+		[Address(RVA = "0x2B21B00", Offset = "0x2B20900", VA = "0x182B21B00")]
+		private static byte[] GetBytesLE(int val)
+		{
+			return null;
+		}
+
+		// Token: 0x0600016C RID: 364 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x600016C")]
+		[Address(RVA = "0x2B22CB0", Offset = "0x2B21AB0", VA = "0x182B22CB0")]
+		private static byte[] Trim(byte[] array)
+		{
+			return null;
+		}
+
+		// Token: 0x0600016D RID: 365 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x600016D")]
+		[Address(RVA = "0x2B20DE0", Offset = "0x2B1FBE0", VA = "0x182B20DE0")]
+		public static RSA FromCapiPrivateKeyBlob(byte[] blob, int offset)
+		{
+			return null;
+		}
+
+		// Token: 0x0600016E RID: 366 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x600016E")]
+		[Address(RVA = "0x2B209D0", Offset = "0x2B1F7D0", VA = "0x182B209D0")]
+		public static DSA FromCapiPrivateKeyBlobDSA(byte[] blob, int offset)
+		{
+			return null;
+		}
+
+		// Token: 0x0600016F RID: 367 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x600016F")]
+		[Address(RVA = "0x2B21FA0", Offset = "0x2B20DA0", VA = "0x182B21FA0")]
+		public static byte[] ToCapiPrivateKeyBlob(RSA rsa)
+		{
+			return null;
+		}
+
+		// Token: 0x06000170 RID: 368 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000170")]
+		[Address(RVA = "0x2B21BC0", Offset = "0x2B209C0", VA = "0x182B21BC0")]
+		public static byte[] ToCapiPrivateKeyBlob(DSA dsa)
+		{
+			return null;
+		}
+
+		// Token: 0x06000171 RID: 369 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000171")]
+		[Address(RVA = "0x2B21750", Offset = "0x2B20550", VA = "0x182B21750")]
+		public static RSA FromCapiPublicKeyBlob(byte[] blob, int offset)
+		{
+			return null;
+		}
+
+		// Token: 0x06000172 RID: 370 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000172")]
+		[Address(RVA = "0x2B21350", Offset = "0x2B20150", VA = "0x182B21350")]
+		public static DSA FromCapiPublicKeyBlobDSA(byte[] blob, int offset)
+		{
+			return null;
+		}
+
+		// Token: 0x06000173 RID: 371 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000173")]
+		[Address(RVA = "0x2B228A0", Offset = "0x2B216A0", VA = "0x182B228A0")]
+		public static byte[] ToCapiPublicKeyBlob(RSA rsa)
+		{
+			return null;
+		}
+
+		// Token: 0x06000174 RID: 372 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000174")]
+		[Address(RVA = "0x2B224C0", Offset = "0x2B212C0", VA = "0x182B224C0")]
+		public static byte[] ToCapiPublicKeyBlob(DSA dsa)
+		{
+			return null;
+		}
+
+		// Token: 0x06000175 RID: 373 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000175")]
+		[Address(RVA = "0x2B20710", Offset = "0x2B1F510", VA = "0x182B20710")]
+		public static RSA FromCapiKeyBlob(byte[] blob)
+		{
+			return null;
+		}
+
+		// Token: 0x06000176 RID: 374 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000176")]
+		[Address(RVA = "0x2B20860", Offset = "0x2B1F660", VA = "0x182B20860")]
+		public static RSA FromCapiKeyBlob(byte[] blob, int offset)
+		{
+			return null;
+		}
+
+		// Token: 0x06000177 RID: 375 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000177")]
+		[Address(RVA = "0x2B204E0", Offset = "0x2B1F2E0", VA = "0x182B204E0")]
+		public static DSA FromCapiKeyBlobDSA(byte[] blob)
+		{
+			return null;
+		}
+
+		// Token: 0x06000178 RID: 376 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000178")]
+		[Address(RVA = "0x2B205F0", Offset = "0x2B1F3F0", VA = "0x182B205F0")]
+		public static DSA FromCapiKeyBlobDSA(byte[] blob, int offset)
+		{
+			return null;
+		}
+	}
+}

mscorlib/Mono/Security/Cryptography/DSAManaged.cs

@@ -0,0 +1,251 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Security.Cryptography;
+using Cpp2IlInjected;
+using Mono.Math;
+
+namespace Mono.Security.Cryptography
+{
+	// Token: 0x0200004D RID: 77
+	[Token(Token = "0x200004D")]
+	internal class DSAManaged : DSA
+	{
+		// Token: 0x06000208 RID: 520 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000208")]
+		[Address(RVA = "0x2B24800", Offset = "0x2B23600", VA = "0x182B24800")]
+		public DSAManaged(int dwKeySize)
+		{
+		}
+
+		// Token: 0x06000209 RID: 521 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000209")]
+		[Address(RVA = "0x2B23620", Offset = "0x2B22420", VA = "0x182B23620", Slot = "1")]
+		protected override void Finalize()
+		{
+		}
+
+		// Token: 0x0600020A RID: 522 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600020A")]
+		[Address(RVA = "0x2B23E30", Offset = "0x2B22C30", VA = "0x182B23E30")]
+		private void Generate()
+		{
+		}
+
+		// Token: 0x0600020B RID: 523 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600020B")]
+		[Address(RVA = "0x2B236A0", Offset = "0x2B224A0", VA = "0x182B236A0")]
+		private void GenerateKeyPair()
+		{
+		}
+
+		// Token: 0x0600020C RID: 524 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600020C")]
+		[Address(RVA = "0x2B24980", Offset = "0x2B23780", VA = "0x182B24980")]
+		private void add(byte[] a, byte[] b, int value)
+		{
+		}
+
+		// Token: 0x0600020D RID: 525 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600020D")]
+		[Address(RVA = "0x2B237B0", Offset = "0x2B225B0", VA = "0x182B237B0")]
+		private void GenerateParams(int keyLength)
+		{
+		}
+
+		// Token: 0x17000055 RID: 85
+		// (get) Token: 0x0600020E RID: 526 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x17000055")]
+		private RandomNumberGenerator Random
+		{
+			[Token(Token = "0x600020E")]
+			[Address(RVA = "0x2B24AD0", Offset = "0x2B238D0", VA = "0x182B24AD0")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x17000056 RID: 86
+		// (get) Token: 0x0600020F RID: 527 RVA: 0x00002E50 File Offset: 0x00001050
+		[Token(Token = "0x17000056")]
+		public override int KeySize
+		{
+			[Token(Token = "0x600020F")]
+			[Address(RVA = "0x2B24A30", Offset = "0x2B23830", VA = "0x182B24A30", Slot = "6")]
+			get
+			{
+				return 0;
+			}
+		}
+
+		// Token: 0x17000057 RID: 87
+		// (get) Token: 0x06000210 RID: 528 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x17000057")]
+		public override string KeyExchangeAlgorithm
+		{
+			[Token(Token = "0x6000210")]
+			[Address(RVA = "0x43E630", Offset = "0x43D430", VA = "0x18043E630", Slot = "10")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x17000058 RID: 88
+		// (get) Token: 0x06000211 RID: 529 RVA: 0x00002E68 File Offset: 0x00001068
+		[Token(Token = "0x17000058")]
+		public bool PublicOnly
+		{
+			[Token(Token = "0x6000211")]
+			[Address(RVA = "0x2B24A60", Offset = "0x2B23860", VA = "0x182B24A60")]
+			get
+			{
+				return default(bool);
+			}
+		}
+
+		// Token: 0x17000059 RID: 89
+		// (get) Token: 0x06000212 RID: 530 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x17000059")]
+		public override string SignatureAlgorithm
+		{
+			[Token(Token = "0x6000212")]
+			[Address(RVA = "0x2B24B00", Offset = "0x2B23900", VA = "0x182B24B00", Slot = "9")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x06000213 RID: 531 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000213")]
+		[Address(RVA = "0x2B242D0", Offset = "0x2B230D0", VA = "0x182B242D0")]
+		private byte[] NormalizeArray(byte[] array)
+		{
+			return null;
+		}
+
+		// Token: 0x06000214 RID: 532 RVA: 0x00002E80 File Offset: 0x00001080
+		[Token(Token = "0x6000214")]
+		[Address(RVA = "0x2B23350", Offset = "0x2B22150", VA = "0x182B23350", Slot = "21")]
+		public override DSAParameters ExportParameters(bool includePrivateParameters)
+		{
+			return default(DSAParameters);
+		}
+
+		// Token: 0x06000215 RID: 533 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000215")]
+		[Address(RVA = "0x2B23F70", Offset = "0x2B22D70", VA = "0x182B23F70", Slot = "22")]
+		public override void ImportParameters(DSAParameters parameters)
+		{
+		}
+
+		// Token: 0x06000216 RID: 534 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000216")]
+		[Address(RVA = "0x2B22D80", Offset = "0x2B21B80", VA = "0x182B22D80", Slot = "13")]
+		public override byte[] CreateSignature(byte[] rgbHash)
+		{
+			return null;
+		}
+
+		// Token: 0x06000217 RID: 535 RVA: 0x00002E98 File Offset: 0x00001098
+		[Token(Token = "0x6000217")]
+		[Address(RVA = "0x2B24380", Offset = "0x2B23180", VA = "0x182B24380", Slot = "14")]
+		public override bool VerifySignature(byte[] rgbHash, byte[] rgbSignature)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x06000218 RID: 536 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000218")]
+		[Address(RVA = "0x2B230F0", Offset = "0x2B21EF0", VA = "0x182B230F0", Slot = "5")]
+		protected override void Dispose(bool disposing)
+		{
+		}
+
+		// Token: 0x14000002 RID: 2
+		// (add) Token: 0x06000219 RID: 537 RVA: 0x00002050 File Offset: 0x00000250
+		// (remove) Token: 0x0600021A RID: 538 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x14000002")]
+		public event DSAManaged.KeyGeneratedEventHandler KeyGenerated
+		{
+			[Token(Token = "0x6000219")]
+			[Address(RVA = "0x2B248E0", Offset = "0x2B236E0", VA = "0x182B248E0")]
+			[CompilerGenerated]
+			add
+			{
+			}
+			[Token(Token = "0x600021A")]
+			[Address(RVA = "0x2B24B30", Offset = "0x2B23930", VA = "0x182B24B30")]
+			[CompilerGenerated]
+			remove
+			{
+			}
+		}
+
+		// Token: 0x04000142 RID: 322
+		[FieldOffset(Offset = "0x20")]
+		[Token(Token = "0x4000142")]
+		private bool keypairGenerated;
+
+		// Token: 0x04000143 RID: 323
+		[FieldOffset(Offset = "0x21")]
+		[Token(Token = "0x4000143")]
+		private bool m_disposed;
+
+		// Token: 0x04000144 RID: 324
+		[FieldOffset(Offset = "0x28")]
+		[Token(Token = "0x4000144")]
+		private BigInteger p;
+
+		// Token: 0x04000145 RID: 325
+		[FieldOffset(Offset = "0x30")]
+		[Token(Token = "0x4000145")]
+		private BigInteger q;
+
+		// Token: 0x04000146 RID: 326
+		[FieldOffset(Offset = "0x38")]
+		[Token(Token = "0x4000146")]
+		private BigInteger g;
+
+		// Token: 0x04000147 RID: 327
+		[FieldOffset(Offset = "0x40")]
+		[Token(Token = "0x4000147")]
+		private BigInteger x;
+
+		// Token: 0x04000148 RID: 328
+		[FieldOffset(Offset = "0x48")]
+		[Token(Token = "0x4000148")]
+		private BigInteger y;
+
+		// Token: 0x04000149 RID: 329
+		[FieldOffset(Offset = "0x50")]
+		[Token(Token = "0x4000149")]
+		private BigInteger j;
+
+		// Token: 0x0400014A RID: 330
+		[FieldOffset(Offset = "0x58")]
+		[Token(Token = "0x400014A")]
+		private BigInteger seed;
+
+		// Token: 0x0400014B RID: 331
+		[FieldOffset(Offset = "0x60")]
+		[Token(Token = "0x400014B")]
+		private int counter;
+
+		// Token: 0x0400014C RID: 332
+		[FieldOffset(Offset = "0x64")]
+		[Token(Token = "0x400014C")]
+		private bool j_missing;
+
+		// Token: 0x0400014D RID: 333
+		[FieldOffset(Offset = "0x68")]
+		[Token(Token = "0x400014D")]
+		private RandomNumberGenerator rng;
+
+		// Token: 0x0200004E RID: 78
+		// (Invoke) Token: 0x0600021C RID: 540
+		[Token(Token = "0x200004E")]
+		public delegate void KeyGeneratedEventHandler(object sender, EventArgs e);
+	}
+}

mscorlib/Mono/Security/Cryptography/KeyBuilder.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Security.Cryptography;
+using Cpp2IlInjected;
+
+namespace Mono.Security.Cryptography
+{
+	// Token: 0x0200003F RID: 63
+	[Token(Token = "0x200003F")]
+	internal sealed class KeyBuilder
+	{
+		// Token: 0x1700003B RID: 59
+		// (get) Token: 0x06000179 RID: 377 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x1700003B")]
+		private static RandomNumberGenerator Rng
+		{
+			[Token(Token = "0x6000179")]
+			[Address(RVA = "0x2B25DC0", Offset = "0x2B24BC0", VA = "0x182B25DC0")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x0600017A RID: 378 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x600017A")]
+		[Address(RVA = "0x2B25D00", Offset = "0x2B24B00", VA = "0x182B25D00")]
+		public static byte[] Key(int size)
+		{
+			return null;
+		}
+
+		// Token: 0x0600017B RID: 379 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x600017B")]
+		[Address(RVA = "0x2B25C40", Offset = "0x2B24A40", VA = "0x182B25C40")]
+		public static byte[] IV(int size)
+		{
+			return null;
+		}
+
+		// Token: 0x04000106 RID: 262
+		[Token(Token = "0x4000106")]
+		private static RandomNumberGenerator rng;
+	}
+}

mscorlib/Mono/Security/Cryptography/KeyPairPersistence.cs

@@ -0,0 +1,313 @@
+using System;
+using System.Security.Cryptography;
+using Cpp2IlInjected;
+
+namespace Mono.Security.Cryptography
+{
+	// Token: 0x02000040 RID: 64
+	[Token(Token = "0x2000040")]
+	internal class KeyPairPersistence
+	{
+		// Token: 0x0600017C RID: 380 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600017C")]
+		[Address(RVA = "0x2B26910", Offset = "0x2B25710", VA = "0x182B26910")]
+		public KeyPairPersistence(CspParameters parameters)
+		{
+		}
+
+		// Token: 0x0600017D RID: 381 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600017D")]
+		[Address(RVA = "0x2B269A0", Offset = "0x2B257A0", VA = "0x182B269A0")]
+		public KeyPairPersistence(CspParameters parameters, string keyPair)
+		{
+		}
+
+		// Token: 0x1700003C RID: 60
+		// (get) Token: 0x0600017E RID: 382 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x1700003C")]
+		public string Filename
+		{
+			[Token(Token = "0x600017E")]
+			[Address(RVA = "0x2B26BD0", Offset = "0x2B259D0", VA = "0x182B26BD0")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x1700003D RID: 61
+		// (get) Token: 0x0600017F RID: 383 RVA: 0x00002082 File Offset: 0x00000282
+		// (set) Token: 0x06000180 RID: 384 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x1700003D")]
+		public string KeyValue
+		{
+			[Token(Token = "0x600017F")]
+			[Address(RVA = "0x3F5F40", Offset = "0x3F4D40", VA = "0x1803F5F40")]
+			get
+			{
+				return null;
+			}
+			[Token(Token = "0x6000180")]
+			[Address(RVA = "0x2B277C0", Offset = "0x2B265C0", VA = "0x182B277C0")]
+			set
+			{
+			}
+		}
+
+		// Token: 0x1700003E RID: 62
+		// (get) Token: 0x06000181 RID: 385 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x1700003E")]
+		public CspParameters Parameters
+		{
+			[Token(Token = "0x6000181")]
+			[Address(RVA = "0x2B27270", Offset = "0x2B26070", VA = "0x182B27270")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x06000182 RID: 386 RVA: 0x00002B20 File Offset: 0x00000D20
+		[Token(Token = "0x6000182")]
+		[Address(RVA = "0x2B261C0", Offset = "0x2B24FC0", VA = "0x182B261C0")]
+		public bool Load()
+		{
+			return default(bool);
+		}
+
+		// Token: 0x06000183 RID: 387 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000183")]
+		[Address(RVA = "0x2B26520", Offset = "0x2B25320", VA = "0x182B26520")]
+		public void Save()
+		{
+		}
+
+		// Token: 0x06000184 RID: 388 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000184")]
+		[Address(RVA = "0x2B26500", Offset = "0x2B25300", VA = "0x182B26500")]
+		public void Remove()
+		{
+		}
+
+		// Token: 0x1700003F RID: 63
+		// (get) Token: 0x06000185 RID: 389 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x1700003F")]
+		private static string UserPath
+		{
+			[Token(Token = "0x6000185")]
+			[Address(RVA = "0x2B272C0", Offset = "0x2B260C0", VA = "0x182B272C0")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x17000040 RID: 64
+		// (get) Token: 0x06000186 RID: 390 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x17000040")]
+		private static string MachinePath
+		{
+			[Token(Token = "0x6000186")]
+			[Address(RVA = "0x2B26D70", Offset = "0x2B25B70", VA = "0x182B26D70")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x06000187 RID: 391 RVA: 0x00002B38 File Offset: 0x00000D38
+		[Token(Token = "0x6000187")]
+		[Address(RVA = "0x1B65780", Offset = "0x1B64580", VA = "0x181B65780")]
+		internal static bool _CanSecure(string root)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x06000188 RID: 392 RVA: 0x00002B50 File Offset: 0x00000D50
+		[Token(Token = "0x6000188")]
+		[Address(RVA = "0x1B65780", Offset = "0x1B64580", VA = "0x181B65780")]
+		internal static bool _ProtectUser(string path)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x06000189 RID: 393 RVA: 0x00002B68 File Offset: 0x00000D68
+		[Token(Token = "0x6000189")]
+		[Address(RVA = "0x1B65780", Offset = "0x1B64580", VA = "0x181B65780")]
+		internal static bool _ProtectMachine(string path)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x0600018A RID: 394 RVA: 0x00002B80 File Offset: 0x00000D80
+		[Token(Token = "0x600018A")]
+		[Address(RVA = "0x1B65780", Offset = "0x1B64580", VA = "0x181B65780")]
+		internal static bool _IsUserProtected(string path)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x0600018B RID: 395 RVA: 0x00002B98 File Offset: 0x00000D98
+		[Token(Token = "0x600018B")]
+		[Address(RVA = "0x1B65780", Offset = "0x1B64580", VA = "0x181B65780")]
+		internal static bool _IsMachineProtected(string path)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x0600018C RID: 396 RVA: 0x00002BB0 File Offset: 0x00000DB0
+		[Token(Token = "0x600018C")]
+		[Address(RVA = "0x2B25E30", Offset = "0x2B24C30", VA = "0x182B25E30")]
+		private static bool CanSecure(string path)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x0600018D RID: 397 RVA: 0x00002BC8 File Offset: 0x00000DC8
+		[Token(Token = "0x600018D")]
+		[Address(RVA = "0x2B26470", Offset = "0x2B25270", VA = "0x182B26470")]
+		private static bool ProtectUser(string path)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x0600018E RID: 398 RVA: 0x00002BE0 File Offset: 0x00000DE0
+		[Token(Token = "0x600018E")]
+		[Address(RVA = "0x2B263E0", Offset = "0x2B251E0", VA = "0x182B263E0")]
+		private static bool ProtectMachine(string path)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x0600018F RID: 399 RVA: 0x00002BF8 File Offset: 0x00000DF8
+		[Token(Token = "0x600018F")]
+		[Address(RVA = "0x2B26130", Offset = "0x2B24F30", VA = "0x182B26130")]
+		private static bool IsUserProtected(string path)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x06000190 RID: 400 RVA: 0x00002C10 File Offset: 0x00000E10
+		[Token(Token = "0x6000190")]
+		[Address(RVA = "0x2B260A0", Offset = "0x2B24EA0", VA = "0x182B260A0")]
+		private static bool IsMachineProtected(string path)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x17000041 RID: 65
+		// (get) Token: 0x06000191 RID: 401 RVA: 0x00002C28 File Offset: 0x00000E28
+		[Token(Token = "0x17000041")]
+		private bool CanChange
+		{
+			[Token(Token = "0x6000191")]
+			[Address(RVA = "0x2B26A40", Offset = "0x2B25840", VA = "0x182B26A40")]
+			get
+			{
+				return default(bool);
+			}
+		}
+
+		// Token: 0x17000042 RID: 66
+		// (get) Token: 0x06000192 RID: 402 RVA: 0x00002C40 File Offset: 0x00000E40
+		[Token(Token = "0x17000042")]
+		private bool UseDefaultKeyContainer
+		{
+			[Token(Token = "0x6000192")]
+			[Address(RVA = "0x2B27280", Offset = "0x2B26080", VA = "0x182B27280")]
+			get
+			{
+				return default(bool);
+			}
+		}
+
+		// Token: 0x17000043 RID: 67
+		// (get) Token: 0x06000193 RID: 403 RVA: 0x00002C58 File Offset: 0x00000E58
+		[Token(Token = "0x17000043")]
+		private bool UseMachineKeyStore
+		{
+			[Token(Token = "0x6000193")]
+			[Address(RVA = "0x2B272A0", Offset = "0x2B260A0", VA = "0x182B272A0")]
+			get
+			{
+				return default(bool);
+			}
+		}
+
+		// Token: 0x17000044 RID: 68
+		// (get) Token: 0x06000194 RID: 404 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x17000044")]
+		private string ContainerName
+		{
+			[Token(Token = "0x6000194")]
+			[Address(RVA = "0x2B26A50", Offset = "0x2B25850", VA = "0x182B26A50")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x06000195 RID: 405 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000195")]
+		[Address(RVA = "0x2B25EE0", Offset = "0x2B24CE0", VA = "0x182B25EE0")]
+		private CspParameters Copy(CspParameters p)
+		{
+			return null;
+		}
+
+		// Token: 0x06000196 RID: 406 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000196")]
+		[Address(RVA = "0x2B25F90", Offset = "0x2B24D90", VA = "0x182B25F90")]
+		private void FromXml(string xml)
+		{
+		}
+
+		// Token: 0x06000197 RID: 407 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000197")]
+		[Address(RVA = "0x2B266E0", Offset = "0x2B254E0", VA = "0x182B266E0")]
+		private string ToXml()
+		{
+			return null;
+		}
+
+		// Token: 0x04000107 RID: 263
+		[Token(Token = "0x4000107")]
+		private static bool _userPathExists;
+
+		// Token: 0x04000108 RID: 264
+		[Token(Token = "0x4000108")]
+		private static string _userPath;
+
+		// Token: 0x04000109 RID: 265
+		[Token(Token = "0x4000109")]
+		private static bool _machinePathExists;
+
+		// Token: 0x0400010A RID: 266
+		[Token(Token = "0x400010A")]
+		private static string _machinePath;
+
+		// Token: 0x0400010B RID: 267
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x400010B")]
+		private CspParameters _params;
+
+		// Token: 0x0400010C RID: 268
+		[FieldOffset(Offset = "0x18")]
+		[Token(Token = "0x400010C")]
+		private string _keyvalue;
+
+		// Token: 0x0400010D RID: 269
+		[FieldOffset(Offset = "0x20")]
+		[Token(Token = "0x400010D")]
+		private string _filename;
+
+		// Token: 0x0400010E RID: 270
+		[FieldOffset(Offset = "0x28")]
+		[Token(Token = "0x400010E")]
+		private string _container;
+
+		// Token: 0x0400010F RID: 271
+		[Token(Token = "0x400010F")]
+		private static object lockobj;
+	}
+}

mscorlib/Mono/Security/Cryptography/MD2.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Security.Cryptography;
+using Cpp2IlInjected;
+
+namespace Mono.Security.Cryptography
+{
+	// Token: 0x02000041 RID: 65
+	[Token(Token = "0x2000041")]
+	internal abstract class MD2 : HashAlgorithm
+	{
+		// Token: 0x06000199 RID: 409 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000199")]
+		[Address(RVA = "0x63B0E0", Offset = "0x639EE0", VA = "0x18063B0E0")]
+		protected MD2()
+		{
+		}
+
+		// Token: 0x0600019A RID: 410 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x600019A")]
+		[Address(RVA = "0x2B27EF0", Offset = "0x2B26CF0", VA = "0x182B27EF0")]
+		public new static MD2 Create()
+		{
+			return null;
+		}
+	}
+}

mscorlib/Mono/Security/Cryptography/MD2Managed.cs

@@ -0,0 +1,83 @@
+using System;
+using Cpp2IlInjected;
+
+namespace Mono.Security.Cryptography
+{
+	// Token: 0x02000042 RID: 66
+	[Token(Token = "0x2000042")]
+	internal class MD2Managed : MD2
+	{
+		// Token: 0x0600019B RID: 411 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x600019B")]
+		[Address(RVA = "0x2B27D50", Offset = "0x2B26B50", VA = "0x182B27D50")]
+		private byte[] Padding(int nLength)
+		{
+			return null;
+		}
+
+		// Token: 0x0600019C RID: 412 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600019C")]
+		[Address(RVA = "0x2B27E40", Offset = "0x2B26C40", VA = "0x182B27E40")]
+		public MD2Managed()
+		{
+		}
+
+		// Token: 0x0600019D RID: 413 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600019D")]
+		[Address(RVA = "0x63AAF0", Offset = "0x6398F0", VA = "0x18063AAF0", Slot = "18")]
+		public override void Initialize()
+		{
+		}
+
+		// Token: 0x0600019E RID: 414 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600019E")]
+		[Address(RVA = "0x2B277D0", Offset = "0x2B265D0", VA = "0x182B277D0", Slot = "19")]
+		protected override void HashCore(byte[] array, int ibStart, int cbSize)
+		{
+		}
+
+		// Token: 0x0600019F RID: 415 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x600019F")]
+		[Address(RVA = "0x2B278D0", Offset = "0x2B266D0", VA = "0x182B278D0", Slot = "20")]
+		protected override byte[] HashFinal()
+		{
+			return null;
+		}
+
+		// Token: 0x060001A0 RID: 416 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60001A0")]
+		[Address(RVA = "0x2B27A30", Offset = "0x2B26830", VA = "0x182B27A30")]
+		private void MD2Transform(byte[] state, byte[] checksum, byte[] block, int index)
+		{
+		}
+
+		// Token: 0x04000110 RID: 272
+		[FieldOffset(Offset = "0x28")]
+		[Token(Token = "0x4000110")]
+		private byte[] state;
+
+		// Token: 0x04000111 RID: 273
+		[FieldOffset(Offset = "0x30")]
+		[Token(Token = "0x4000111")]
+		private byte[] checksum;
+
+		// Token: 0x04000112 RID: 274
+		[FieldOffset(Offset = "0x38")]
+		[Token(Token = "0x4000112")]
+		private byte[] buffer;
+
+		// Token: 0x04000113 RID: 275
+		[FieldOffset(Offset = "0x40")]
+		[Token(Token = "0x4000113")]
+		private int count;
+
+		// Token: 0x04000114 RID: 276
+		[FieldOffset(Offset = "0x48")]
+		[Token(Token = "0x4000114")]
+		private byte[] x;
+
+		// Token: 0x04000115 RID: 277
+		[Token(Token = "0x4000115")]
+		private static readonly byte[] PI_SUBST;
+	}
+}

mscorlib/Mono/Security/Cryptography/MD4.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Security.Cryptography;
+using Cpp2IlInjected;
+
+namespace Mono.Security.Cryptography
+{
+	// Token: 0x02000043 RID: 67
+	[Token(Token = "0x2000043")]
+	internal abstract class MD4 : HashAlgorithm
+	{
+		// Token: 0x060001A2 RID: 418 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60001A2")]
+		[Address(RVA = "0x63B0E0", Offset = "0x639EE0", VA = "0x18063B0E0")]
+		protected MD4()
+		{
+		}
+
+		// Token: 0x060001A3 RID: 419 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60001A3")]
+		[Address(RVA = "0x2B28270", Offset = "0x2B27070", VA = "0x182B28270")]
+		public new static MD4 Create()
+		{
+			return null;
+		}
+	}
+}

mscorlib/Mono/Security/Cryptography/MD4Managed.cs

@@ -0,0 +1,146 @@
+using System;
+using Cpp2IlInjected;
+
+namespace Mono.Security.Cryptography
+{
+	// Token: 0x02000044 RID: 68
+	[Token(Token = "0x2000044")]
+	internal class MD4Managed : MD4
+	{
+		// Token: 0x060001A4 RID: 420 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60001A4")]
+		[Address(RVA = "0x2B281B0", Offset = "0x2B26FB0", VA = "0x182B281B0")]
+		public MD4Managed()
+		{
+		}
+
+		// Token: 0x060001A5 RID: 421 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60001A5")]
+		[Address(RVA = "0x63B7C0", Offset = "0x63A5C0", VA = "0x18063B7C0", Slot = "18")]
+		public override void Initialize()
+		{
+		}
+
+		// Token: 0x060001A6 RID: 422 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60001A6")]
+		[Address(RVA = "0x63B470", Offset = "0x63A270", VA = "0x18063B470", Slot = "19")]
+		protected override void HashCore(byte[] array, int ibStart, int cbSize)
+		{
+		}
+
+		// Token: 0x060001A7 RID: 423 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60001A7")]
+		[Address(RVA = "0x2B27FC0", Offset = "0x2B26DC0", VA = "0x182B27FC0", Slot = "20")]
+		protected override byte[] HashFinal()
+		{
+			return null;
+		}
+
+		// Token: 0x060001A8 RID: 424 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60001A8")]
+		[Address(RVA = "0x2B28140", Offset = "0x2B26F40", VA = "0x182B28140")]
+		private byte[] Padding(int nLength)
+		{
+			return null;
+		}
+
+		// Token: 0x060001A9 RID: 425 RVA: 0x00002C70 File Offset: 0x00000E70
+		[Token(Token = "0x60001A9")]
+		[Address(RVA = "0x63B3A0", Offset = "0x63A1A0", VA = "0x18063B3A0")]
+		private uint F(uint x, uint y, uint z)
+		{
+			return 0U;
+		}
+
+		// Token: 0x060001AA RID: 426 RVA: 0x00002C88 File Offset: 0x00000E88
+		[Token(Token = "0x60001AA")]
+		[Address(RVA = "0x63B400", Offset = "0x63A200", VA = "0x18063B400")]
+		private uint G(uint x, uint y, uint z)
+		{
+			return 0U;
+		}
+
+		// Token: 0x060001AB RID: 427 RVA: 0x00002CA0 File Offset: 0x00000EA0
+		[Token(Token = "0x60001AB")]
+		[Address(RVA = "0x63B460", Offset = "0x63A260", VA = "0x18063B460")]
+		private uint H(uint x, uint y, uint z)
+		{
+			return 0U;
+		}
+
+		// Token: 0x060001AC RID: 428 RVA: 0x00002CB8 File Offset: 0x00000EB8
+		[Token(Token = "0x60001AC")]
+		[Address(RVA = "0x63C4D0", Offset = "0x63B2D0", VA = "0x18063C4D0")]
+		private uint ROL(uint x, byte n)
+		{
+			return 0U;
+		}
+
+		// Token: 0x060001AD RID: 429 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60001AD")]
+		[Address(RVA = "0x63B360", Offset = "0x63A160", VA = "0x18063B360")]
+		private void FF(ref uint a, uint b, uint c, uint d, uint x, byte s)
+		{
+		}
+
+		// Token: 0x060001AE RID: 430 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60001AE")]
+		[Address(RVA = "0x63B3B0", Offset = "0x63A1B0", VA = "0x18063B3B0")]
+		private void GG(ref uint a, uint b, uint c, uint d, uint x, byte s)
+		{
+		}
+
+		// Token: 0x060001AF RID: 431 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60001AF")]
+		[Address(RVA = "0x63B410", Offset = "0x63A210", VA = "0x18063B410")]
+		private void HH(ref uint a, uint b, uint c, uint d, uint x, byte s)
+		{
+		}
+
+		// Token: 0x060001B0 RID: 432 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60001B0")]
+		[Address(RVA = "0x63B210", Offset = "0x63A010", VA = "0x18063B210")]
+		private void Encode(byte[] output, uint[] input)
+		{
+		}
+
+		// Token: 0x060001B1 RID: 433 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60001B1")]
+		[Address(RVA = "0x63B100", Offset = "0x639F00", VA = "0x18063B100")]
+		private void Decode(uint[] output, byte[] input, int index)
+		{
+		}
+
+		// Token: 0x060001B2 RID: 434 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60001B2")]
+		[Address(RVA = "0x63B900", Offset = "0x63A700", VA = "0x18063B900")]
+		private void MD4Transform(uint[] state, byte[] block, int index)
+		{
+		}
+
+		// Token: 0x04000116 RID: 278
+		[FieldOffset(Offset = "0x28")]
+		[Token(Token = "0x4000116")]
+		private uint[] state;
+
+		// Token: 0x04000117 RID: 279
+		[FieldOffset(Offset = "0x30")]
+		[Token(Token = "0x4000117")]
+		private byte[] buffer;
+
+		// Token: 0x04000118 RID: 280
+		[FieldOffset(Offset = "0x38")]
+		[Token(Token = "0x4000118")]
+		private uint[] count;
+
+		// Token: 0x04000119 RID: 281
+		[FieldOffset(Offset = "0x40")]
+		[Token(Token = "0x4000119")]
+		private uint[] x;
+
+		// Token: 0x0400011A RID: 282
+		[FieldOffset(Offset = "0x48")]
+		[Token(Token = "0x400011A")]
+		private byte[] digest;
+	}
+}

mscorlib/Mono/Security/Cryptography/PKCS1.cs

@@ -0,0 +1,187 @@
+using System;
+using System.Security.Cryptography;
+using Cpp2IlInjected;
+
+namespace Mono.Security.Cryptography
+{
+	// Token: 0x02000045 RID: 69
+	[Token(Token = "0x2000045")]
+	internal sealed class PKCS1
+	{
+		// Token: 0x060001B3 RID: 435 RVA: 0x00002CD0 File Offset: 0x00000ED0
+		[Token(Token = "0x60001B3")]
+		[Address(RVA = "0x2B2DEB0", Offset = "0x2B2CCB0", VA = "0x182B2DEB0")]
+		private static bool Compare(byte[] array1, byte[] array2)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x060001B4 RID: 436 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60001B4")]
+		[Address(RVA = "0x2B2FAE0", Offset = "0x2B2E8E0", VA = "0x182B2FAE0")]
+		private static byte[] xor(byte[] array1, byte[] array2)
+		{
+			return null;
+		}
+
+		// Token: 0x060001B5 RID: 437 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60001B5")]
+		[Address(RVA = "0x2B2ED00", Offset = "0x2B2DB00", VA = "0x182B2ED00")]
+		private static byte[] GetEmptyHash(HashAlgorithm hash)
+		{
+			return null;
+		}
+
+		// Token: 0x060001B6 RID: 438 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60001B6")]
+		[Address(RVA = "0x2B2EF80", Offset = "0x2B2DD80", VA = "0x182B2EF80")]
+		public static byte[] I2OSP(int x, int size)
+		{
+			return null;
+		}
+
+		// Token: 0x060001B7 RID: 439 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60001B7")]
+		[Address(RVA = "0x2B2EF00", Offset = "0x2B2DD00", VA = "0x182B2EF00")]
+		public static byte[] I2OSP(byte[] x, int size)
+		{
+			return null;
+		}
+
+		// Token: 0x060001B8 RID: 440 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60001B8")]
+		[Address(RVA = "0x2B2F250", Offset = "0x2B2E050", VA = "0x182B2F250")]
+		public static byte[] OS2IP(byte[] x)
+		{
+			return null;
+		}
+
+		// Token: 0x060001B9 RID: 441 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60001B9")]
+		[Address(RVA = "0x2B2F350", Offset = "0x2B2E150", VA = "0x182B2F350")]
+		public static byte[] RSAEP(RSA rsa, byte[] m)
+		{
+			return null;
+		}
+
+		// Token: 0x060001BA RID: 442 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60001BA")]
+		[Address(RVA = "0x2B2F320", Offset = "0x2B2E120", VA = "0x182B2F320")]
+		public static byte[] RSADP(RSA rsa, byte[] c)
+		{
+			return null;
+		}
+
+		// Token: 0x060001BB RID: 443 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60001BB")]
+		[Address(RVA = "0x2B2F320", Offset = "0x2B2E120", VA = "0x182B2F320")]
+		public static byte[] RSASP1(RSA rsa, byte[] m)
+		{
+			return null;
+		}
+
+		// Token: 0x060001BC RID: 444 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60001BC")]
+		[Address(RVA = "0x2B2F350", Offset = "0x2B2E150", VA = "0x182B2F350")]
+		public static byte[] RSAVP1(RSA rsa, byte[] s)
+		{
+			return null;
+		}
+
+		// Token: 0x060001BD RID: 445 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60001BD")]
+		[Address(RVA = "0x2B2EA00", Offset = "0x2B2D800", VA = "0x182B2EA00")]
+		public static byte[] Encrypt_OAEP(RSA rsa, HashAlgorithm hash, RandomNumberGenerator rng, byte[] M)
+		{
+			return null;
+		}
+
+		// Token: 0x060001BE RID: 446 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60001BE")]
+		[Address(RVA = "0x2B2E3D0", Offset = "0x2B2D1D0", VA = "0x182B2E3D0")]
+		public static byte[] Decrypt_OAEP(RSA rsa, HashAlgorithm hash, byte[] C)
+		{
+			return null;
+		}
+
+		// Token: 0x060001BF RID: 447 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60001BF")]
+		[Address(RVA = "0x2B2F380", Offset = "0x2B2E180", VA = "0x182B2F380")]
+		public static byte[] Sign_v15(RSA rsa, HashAlgorithm hash, byte[] hashValue)
+		{
+			return null;
+		}
+
+		// Token: 0x060001C0 RID: 448 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60001C0")]
+		[Address(RVA = "0x2B2F450", Offset = "0x2B2E250", VA = "0x182B2F450")]
+		internal static byte[] Sign_v15(RSA rsa, string hashName, byte[] hashValue)
+		{
+			return null;
+		}
+
+		// Token: 0x060001C1 RID: 449 RVA: 0x00002CE8 File Offset: 0x00000EE8
+		[Token(Token = "0x60001C1")]
+		[Address(RVA = "0x2B2F940", Offset = "0x2B2E740", VA = "0x182B2F940")]
+		public static bool Verify_v15(RSA rsa, HashAlgorithm hash, byte[] hashValue, byte[] signature)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x060001C2 RID: 450 RVA: 0x00002D00 File Offset: 0x00000F00
+		[Token(Token = "0x60001C2")]
+		[Address(RVA = "0x2B2F820", Offset = "0x2B2E620", VA = "0x182B2F820")]
+		internal static bool Verify_v15(RSA rsa, string hashName, byte[] hashValue, byte[] signature)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x060001C3 RID: 451 RVA: 0x00002D18 File Offset: 0x00000F18
+		[Token(Token = "0x60001C3")]
+		[Address(RVA = "0x2B2F5F0", Offset = "0x2B2E3F0", VA = "0x182B2F5F0")]
+		public static bool Verify_v15(RSA rsa, HashAlgorithm hash, byte[] hashValue, byte[] signature, bool tryNonStandardEncoding)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x060001C4 RID: 452 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60001C4")]
+		[Address(RVA = "0x2B2E700", Offset = "0x2B2D500", VA = "0x182B2E700")]
+		public static byte[] Encode_v15(HashAlgorithm hash, byte[] hashValue, int emLength)
+		{
+			return null;
+		}
+
+		// Token: 0x060001C5 RID: 453 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60001C5")]
+		[Address(RVA = "0x2B2F020", Offset = "0x2B2DE20", VA = "0x182B2F020")]
+		public static byte[] MGF1(HashAlgorithm hash, byte[] mgfSeed, int maskLen)
+		{
+			return null;
+		}
+
+		// Token: 0x060001C6 RID: 454 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60001C6")]
+		[Address(RVA = "0x2B2DF50", Offset = "0x2B2CD50", VA = "0x182B2DF50")]
+		internal static HashAlgorithm CreateFromName(string name)
+		{
+			return null;
+		}
+
+		// Token: 0x0400011B RID: 283
+		[Token(Token = "0x400011B")]
+		private static byte[] emptySHA1;
+
+		// Token: 0x0400011C RID: 284
+		[Token(Token = "0x400011C")]
+		private static byte[] emptySHA256;
+
+		// Token: 0x0400011D RID: 285
+		[Token(Token = "0x400011D")]
+		private static byte[] emptySHA384;
+
+		// Token: 0x0400011E RID: 286
+		[Token(Token = "0x400011E")]
+		private static byte[] emptySHA512;
+	}
+}

mscorlib/Mono/Security/Cryptography/PKCS8.cs

@@ -0,0 +1,201 @@
+using System;
+using System.Collections;
+using System.Security.Cryptography;
+using Cpp2IlInjected;
+
+namespace Mono.Security.Cryptography
+{
+	// Token: 0x02000046 RID: 70
+	[Token(Token = "0x2000046")]
+	internal sealed class PKCS8
+	{
+		// Token: 0x02000047 RID: 71
+		[Token(Token = "0x2000047")]
+		public class PrivateKeyInfo
+		{
+			// Token: 0x060001C8 RID: 456 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x60001C8")]
+			[Address(RVA = "0x2B305C0", Offset = "0x2B2F3C0", VA = "0x182B305C0")]
+			public PrivateKeyInfo()
+			{
+			}
+
+			// Token: 0x060001C9 RID: 457 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x60001C9")]
+			[Address(RVA = "0x2B30540", Offset = "0x2B2F340", VA = "0x182B30540")]
+			public PrivateKeyInfo(byte[] data)
+			{
+			}
+
+			// Token: 0x17000045 RID: 69
+			// (get) Token: 0x060001CA RID: 458 RVA: 0x00002082 File Offset: 0x00000282
+			[Token(Token = "0x17000045")]
+			public byte[] PrivateKey
+			{
+				[Token(Token = "0x60001CA")]
+				[Address(RVA = "0x2B30630", Offset = "0x2B2F430", VA = "0x182B30630")]
+				get
+				{
+					return null;
+				}
+			}
+
+			// Token: 0x060001CB RID: 459 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x60001CB")]
+			[Address(RVA = "0x2B30130", Offset = "0x2B2EF30", VA = "0x182B30130")]
+			private void Decode(byte[] data)
+			{
+			}
+
+			// Token: 0x060001CC RID: 460 RVA: 0x00002082 File Offset: 0x00000282
+			[Token(Token = "0x60001CC")]
+			[Address(RVA = "0x2B30490", Offset = "0x2B2F290", VA = "0x182B30490")]
+			private static byte[] RemoveLeadingZero(byte[] bigInt)
+			{
+				return null;
+			}
+
+			// Token: 0x060001CD RID: 461 RVA: 0x00002082 File Offset: 0x00000282
+			[Token(Token = "0x60001CD")]
+			[Address(RVA = "0x2B303E0", Offset = "0x2B2F1E0", VA = "0x182B303E0")]
+			private static byte[] Normalize(byte[] bigInt, int length)
+			{
+				return null;
+			}
+
+			// Token: 0x060001CE RID: 462 RVA: 0x00002082 File Offset: 0x00000282
+			[Token(Token = "0x60001CE")]
+			[Address(RVA = "0x2B2FCD0", Offset = "0x2B2EAD0", VA = "0x182B2FCD0")]
+			public static RSA DecodeRSA(byte[] keypair)
+			{
+				return null;
+			}
+
+			// Token: 0x060001CF RID: 463 RVA: 0x00002082 File Offset: 0x00000282
+			[Token(Token = "0x60001CF")]
+			[Address(RVA = "0x2B2FBB0", Offset = "0x2B2E9B0", VA = "0x182B2FBB0")]
+			public static DSA DecodeDSA(byte[] privateKey, DSAParameters dsaParameters)
+			{
+				return null;
+			}
+
+			// Token: 0x0400011F RID: 287
+			[FieldOffset(Offset = "0x10")]
+			[Token(Token = "0x400011F")]
+			private int _version;
+
+			// Token: 0x04000120 RID: 288
+			[FieldOffset(Offset = "0x18")]
+			[Token(Token = "0x4000120")]
+			private string _algorithm;
+
+			// Token: 0x04000121 RID: 289
+			[FieldOffset(Offset = "0x20")]
+			[Token(Token = "0x4000121")]
+			private byte[] _key;
+
+			// Token: 0x04000122 RID: 290
+			[FieldOffset(Offset = "0x28")]
+			[Token(Token = "0x4000122")]
+			private ArrayList _list;
+		}
+
+		// Token: 0x02000048 RID: 72
+		[Token(Token = "0x2000048")]
+		public class EncryptedPrivateKeyInfo
+		{
+			// Token: 0x060001D0 RID: 464 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x60001D0")]
+			[Address(RVA = "0x3F5100", Offset = "0x3F3F00", VA = "0x1803F5100")]
+			public EncryptedPrivateKeyInfo()
+			{
+			}
+
+			// Token: 0x060001D1 RID: 465 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x60001D1")]
+			[Address(RVA = "0x2B25AD0", Offset = "0x2B248D0", VA = "0x182B25AD0")]
+			public EncryptedPrivateKeyInfo(byte[] data)
+			{
+			}
+
+			// Token: 0x17000046 RID: 70
+			// (get) Token: 0x060001D2 RID: 466 RVA: 0x00002082 File Offset: 0x00000282
+			[Token(Token = "0x17000046")]
+			public string Algorithm
+			{
+				[Token(Token = "0x60001D2")]
+				[Address(RVA = "0x3F6E20", Offset = "0x3F5C20", VA = "0x1803F6E20")]
+				get
+				{
+					return null;
+				}
+			}
+
+			// Token: 0x17000047 RID: 71
+			// (get) Token: 0x060001D3 RID: 467 RVA: 0x00002082 File Offset: 0x00000282
+			[Token(Token = "0x17000047")]
+			public byte[] EncryptedData
+			{
+				[Token(Token = "0x60001D3")]
+				[Address(RVA = "0x2B25B00", Offset = "0x2B24900", VA = "0x182B25B00")]
+				get
+				{
+					return null;
+				}
+			}
+
+			// Token: 0x17000048 RID: 72
+			// (get) Token: 0x060001D4 RID: 468 RVA: 0x00002082 File Offset: 0x00000282
+			[Token(Token = "0x17000048")]
+			public byte[] Salt
+			{
+				[Token(Token = "0x60001D4")]
+				[Address(RVA = "0x2B25B80", Offset = "0x2B24980", VA = "0x182B25B80")]
+				get
+				{
+					return null;
+				}
+			}
+
+			// Token: 0x17000049 RID: 73
+			// (get) Token: 0x060001D5 RID: 469 RVA: 0x00002D30 File Offset: 0x00000F30
+			[Token(Token = "0x17000049")]
+			public int IterationCount
+			{
+				[Token(Token = "0x60001D5")]
+				[Address(RVA = "0x3F7310", Offset = "0x3F6110", VA = "0x1803F7310")]
+				get
+				{
+					return 0;
+				}
+			}
+
+			// Token: 0x060001D6 RID: 470 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x60001D6")]
+			[Address(RVA = "0x2B257E0", Offset = "0x2B245E0", VA = "0x182B257E0")]
+			private void Decode(byte[] data)
+			{
+			}
+
+			// Token: 0x04000123 RID: 291
+			[FieldOffset(Offset = "0x10")]
+			[Token(Token = "0x4000123")]
+			private string _algorithm;
+
+			// Token: 0x04000124 RID: 292
+			[FieldOffset(Offset = "0x18")]
+			[Token(Token = "0x4000124")]
+			private byte[] _salt;
+
+			// Token: 0x04000125 RID: 293
+			[FieldOffset(Offset = "0x20")]
+			[Token(Token = "0x4000125")]
+			private int _iterations;
+
+			// Token: 0x04000126 RID: 294
+			[FieldOffset(Offset = "0x28")]
+			[Token(Token = "0x4000126")]
+			private byte[] _data;
+		}
+	}
+}

mscorlib/Mono/Security/Cryptography/RC4.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Security.Cryptography;
+using Cpp2IlInjected;
+
+namespace Mono.Security.Cryptography
+{
+	// Token: 0x02000049 RID: 73
+	[Token(Token = "0x2000049")]
+	internal abstract class RC4 : SymmetricAlgorithm
+	{
+		// Token: 0x060001D7 RID: 471 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60001D7")]
+		[Address(RVA = "0x2B30950", Offset = "0x2B2F750", VA = "0x182B30950")]
+		public RC4()
+		{
+		}
+
+		// Token: 0x1700004A RID: 74
+		// (get) Token: 0x060001D8 RID: 472 RVA: 0x00002082 File Offset: 0x00000282
+		// (set) Token: 0x060001D9 RID: 473 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x1700004A")]
+		public override byte[] IV
+		{
+			[Token(Token = "0x60001D8")]
+			[Address(RVA = "0x2B309F0", Offset = "0x2B2F7F0", VA = "0x182B309F0", Slot = "10")]
+			get
+			{
+				return null;
+			}
+			[Token(Token = "0x60001D9")]
+			[Address(RVA = "0x402080", Offset = "0x400E80", VA = "0x180402080", Slot = "11")]
+			set
+			{
+			}
+		}
+
+		// Token: 0x060001DA RID: 474 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60001DA")]
+		[Address(RVA = "0x2B306B0", Offset = "0x2B2F4B0", VA = "0x182B306B0")]
+		public new static RC4 Create()
+		{
+			return null;
+		}
+
+		// Token: 0x04000127 RID: 295
+		[Token(Token = "0x4000127")]
+		private static KeySizes[] s_legalBlockSizes;
+
+		// Token: 0x04000128 RID: 296
+		[Token(Token = "0x4000128")]
+		private static KeySizes[] s_legalKeySizes;
+	}
+}

mscorlib/Mono/Security/Cryptography/RSAManaged.cs

@@ -0,0 +1,238 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Security.Cryptography;
+using Cpp2IlInjected;
+using Mono.Math;
+
+namespace Mono.Security.Cryptography
+{
+	// Token: 0x0200004A RID: 74
+	[Token(Token = "0x200004A")]
+	internal class RSAManaged : RSA
+	{
+		// Token: 0x060001DC RID: 476 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60001DC")]
+		[Address(RVA = "0x2B32550", Offset = "0x2B31350", VA = "0x182B32550")]
+		public RSAManaged(int keySize)
+		{
+		}
+
+		// Token: 0x060001DD RID: 477 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60001DD")]
+		[Address(RVA = "0x2B31630", Offset = "0x2B30430", VA = "0x182B31630", Slot = "1")]
+		protected override void Finalize()
+		{
+		}
+
+		// Token: 0x060001DE RID: 478 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60001DE")]
+		[Address(RVA = "0x2B316B0", Offset = "0x2B304B0", VA = "0x182B316B0")]
+		private void GenerateKeyPair()
+		{
+		}
+
+		// Token: 0x1700004B RID: 75
+		// (get) Token: 0x060001DF RID: 479 RVA: 0x00002D48 File Offset: 0x00000F48
+		[Token(Token = "0x1700004B")]
+		public override int KeySize
+		{
+			[Token(Token = "0x60001DF")]
+			[Address(RVA = "0x2B32730", Offset = "0x2B31530", VA = "0x182B32730", Slot = "6")]
+			get
+			{
+				return 0;
+			}
+		}
+
+		// Token: 0x1700004C RID: 76
+		// (get) Token: 0x060001E0 RID: 480 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x1700004C")]
+		public override string KeyExchangeAlgorithm
+		{
+			[Token(Token = "0x60001E0")]
+			[Address(RVA = "0x2B32700", Offset = "0x2B31500", VA = "0x182B32700", Slot = "10")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x1700004D RID: 77
+		// (get) Token: 0x060001E1 RID: 481 RVA: 0x00002D60 File Offset: 0x00000F60
+		[Token(Token = "0x1700004D")]
+		public bool PublicOnly
+		{
+			[Token(Token = "0x60001E1")]
+			[Address(RVA = "0x2B327E0", Offset = "0x2B315E0", VA = "0x182B327E0")]
+			get
+			{
+				return default(bool);
+			}
+		}
+
+		// Token: 0x1700004E RID: 78
+		// (get) Token: 0x060001E2 RID: 482 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x1700004E")]
+		public override string SignatureAlgorithm
+		{
+			[Token(Token = "0x60001E2")]
+			[Address(RVA = "0x2B32890", Offset = "0x2B31690", VA = "0x182B32890", Slot = "9")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x060001E3 RID: 483 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60001E3")]
+		[Address(RVA = "0x2B30A30", Offset = "0x2B2F830", VA = "0x182B30A30", Slot = "22")]
+		public override byte[] DecryptValue(byte[] rgb)
+		{
+			return null;
+		}
+
+		// Token: 0x060001E4 RID: 484 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60001E4")]
+		[Address(RVA = "0x2B31130", Offset = "0x2B2FF30", VA = "0x182B31130", Slot = "23")]
+		public override byte[] EncryptValue(byte[] rgb)
+		{
+			return null;
+		}
+
+		// Token: 0x060001E5 RID: 485 RVA: 0x00002D78 File Offset: 0x00000F78
+		[Token(Token = "0x60001E5")]
+		[Address(RVA = "0x2B31250", Offset = "0x2B30050", VA = "0x182B31250", Slot = "24")]
+		public override RSAParameters ExportParameters(bool includePrivateParameters)
+		{
+			return default(RSAParameters);
+		}
+
+		// Token: 0x060001E6 RID: 486 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60001E6")]
+		[Address(RVA = "0x2B31A50", Offset = "0x2B30850", VA = "0x182B31A50", Slot = "25")]
+		public override void ImportParameters(RSAParameters parameters)
+		{
+		}
+
+		// Token: 0x060001E7 RID: 487 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60001E7")]
+		[Address(RVA = "0x2B30E70", Offset = "0x2B2FC70", VA = "0x182B30E70", Slot = "5")]
+		protected override void Dispose(bool disposing)
+		{
+		}
+
+		// Token: 0x14000001 RID: 1
+		// (add) Token: 0x060001E8 RID: 488 RVA: 0x00002050 File Offset: 0x00000250
+		// (remove) Token: 0x060001E9 RID: 489 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x14000001")]
+		public event RSAManaged.KeyGeneratedEventHandler KeyGenerated
+		{
+			[Token(Token = "0x60001E8")]
+			[Address(RVA = "0x2B32650", Offset = "0x2B31450", VA = "0x182B32650")]
+			[CompilerGenerated]
+			add
+			{
+			}
+			[Token(Token = "0x60001E9")]
+			[Address(RVA = "0x2B328C0", Offset = "0x2B316C0", VA = "0x182B328C0")]
+			[CompilerGenerated]
+			remove
+			{
+			}
+		}
+
+		// Token: 0x060001EA RID: 490 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60001EA")]
+		[Address(RVA = "0x2B32060", Offset = "0x2B30E60", VA = "0x182B32060", Slot = "12")]
+		public override string ToXmlString(bool includePrivateParameters)
+		{
+			return null;
+		}
+
+		// Token: 0x1700004F RID: 79
+		// (get) Token: 0x060001EB RID: 491 RVA: 0x00002D90 File Offset: 0x00000F90
+		[Token(Token = "0x1700004F")]
+		public bool IsCrtPossible
+		{
+			[Token(Token = "0x60001EB")]
+			[Address(RVA = "0x2B326F0", Offset = "0x2B314F0", VA = "0x182B326F0")]
+			get
+			{
+				return default(bool);
+			}
+		}
+
+		// Token: 0x060001EC RID: 492 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60001EC")]
+		[Address(RVA = "0x2B319A0", Offset = "0x2B307A0", VA = "0x182B319A0")]
+		private byte[] GetPaddedValue(BigInteger value, int length)
+		{
+			return null;
+		}
+
+		// Token: 0x04000129 RID: 297
+		[FieldOffset(Offset = "0x20")]
+		[Token(Token = "0x4000129")]
+		private bool isCRTpossible;
+
+		// Token: 0x0400012A RID: 298
+		[FieldOffset(Offset = "0x21")]
+		[Token(Token = "0x400012A")]
+		private bool keyBlinding;
+
+		// Token: 0x0400012B RID: 299
+		[FieldOffset(Offset = "0x22")]
+		[Token(Token = "0x400012B")]
+		private bool keypairGenerated;
+
+		// Token: 0x0400012C RID: 300
+		[FieldOffset(Offset = "0x23")]
+		[Token(Token = "0x400012C")]
+		private bool m_disposed;
+
+		// Token: 0x0400012D RID: 301
+		[FieldOffset(Offset = "0x28")]
+		[Token(Token = "0x400012D")]
+		private BigInteger d;
+
+		// Token: 0x0400012E RID: 302
+		[FieldOffset(Offset = "0x30")]
+		[Token(Token = "0x400012E")]
+		private BigInteger p;
+
+		// Token: 0x0400012F RID: 303
+		[FieldOffset(Offset = "0x38")]
+		[Token(Token = "0x400012F")]
+		private BigInteger q;
+
+		// Token: 0x04000130 RID: 304
+		[FieldOffset(Offset = "0x40")]
+		[Token(Token = "0x4000130")]
+		private BigInteger dp;
+
+		// Token: 0x04000131 RID: 305
+		[FieldOffset(Offset = "0x48")]
+		[Token(Token = "0x4000131")]
+		private BigInteger dq;
+
+		// Token: 0x04000132 RID: 306
+		[FieldOffset(Offset = "0x50")]
+		[Token(Token = "0x4000132")]
+		private BigInteger qInv;
+
+		// Token: 0x04000133 RID: 307
+		[FieldOffset(Offset = "0x58")]
+		[Token(Token = "0x4000133")]
+		private BigInteger n;
+
+		// Token: 0x04000134 RID: 308
+		[FieldOffset(Offset = "0x60")]
+		[Token(Token = "0x4000134")]
+		private BigInteger e;
+
+		// Token: 0x0200004B RID: 75
+		// (Invoke) Token: 0x060001EE RID: 494
+		[Token(Token = "0x200004B")]
+		public delegate void KeyGeneratedEventHandler(object sender, EventArgs e);
+	}
+}

mscorlib/Mono/Security/Cryptography/SymmetricTransform.cs

@@ -0,0 +1,265 @@
+using System;
+using System.Security.Cryptography;
+using Cpp2IlInjected;
+
+namespace Mono.Security.Cryptography
+{
+	// Token: 0x0200004C RID: 76
+	[Token(Token = "0x200004C")]
+	internal abstract class SymmetricTransform : ICryptoTransform, IDisposable
+	{
+		// Token: 0x060001F1 RID: 497 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60001F1")]
+		[Address(RVA = "0x2B34610", Offset = "0x2B33410", VA = "0x182B34610")]
+		public SymmetricTransform(SymmetricAlgorithm symmAlgo, bool encryption, byte[] rgbIV)
+		{
+		}
+
+		// Token: 0x060001F2 RID: 498 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60001F2")]
+		[Address(RVA = "0x2B33B80", Offset = "0x2B32980", VA = "0x182B33B80", Slot = "1")]
+		protected override void Finalize()
+		{
+		}
+
+		// Token: 0x060001F3 RID: 499 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60001F3")]
+		[Address(RVA = "0x2B33F00", Offset = "0x2B32D00", VA = "0x182B33F00", Slot = "10")]
+		void IDisposable.Dispose()
+		{
+		}
+
+		// Token: 0x060001F4 RID: 500 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60001F4")]
+		[Address(RVA = "0x2B33480", Offset = "0x2B32280", VA = "0x182B33480", Slot = "11")]
+		protected virtual void Dispose(bool disposing)
+		{
+		}
+
+		// Token: 0x17000050 RID: 80
+		// (get) Token: 0x060001F5 RID: 501 RVA: 0x00002DA8 File Offset: 0x00000FA8
+		[Token(Token = "0x17000050")]
+		public virtual bool CanTransformMultipleBlocks
+		{
+			[Token(Token = "0x60001F5")]
+			[Address(RVA = "0x460D40", Offset = "0x45FB40", VA = "0x180460D40", Slot = "12")]
+			get
+			{
+				return default(bool);
+			}
+		}
+
+		// Token: 0x17000051 RID: 81
+		// (get) Token: 0x060001F6 RID: 502 RVA: 0x00002DC0 File Offset: 0x00000FC0
+		[Token(Token = "0x17000051")]
+		public virtual bool CanReuseTransform
+		{
+			[Token(Token = "0x60001F6")]
+			[Address(RVA = "0x403930", Offset = "0x402730", VA = "0x180403930", Slot = "13")]
+			get
+			{
+				return default(bool);
+			}
+		}
+
+		// Token: 0x17000052 RID: 82
+		// (get) Token: 0x060001F7 RID: 503 RVA: 0x00002DD8 File Offset: 0x00000FD8
+		[Token(Token = "0x17000052")]
+		public virtual int InputBlockSize
+		{
+			[Token(Token = "0x60001F7")]
+			[Address(RVA = "0x41F5B0", Offset = "0x41E3B0", VA = "0x18041F5B0", Slot = "14")]
+			get
+			{
+				return 0;
+			}
+		}
+
+		// Token: 0x17000053 RID: 83
+		// (get) Token: 0x060001F8 RID: 504 RVA: 0x00002DF0 File Offset: 0x00000FF0
+		[Token(Token = "0x17000053")]
+		public virtual int OutputBlockSize
+		{
+			[Token(Token = "0x60001F8")]
+			[Address(RVA = "0x41F5B0", Offset = "0x41E3B0", VA = "0x18041F5B0", Slot = "15")]
+			get
+			{
+				return 0;
+			}
+		}
+
+		// Token: 0x060001F9 RID: 505 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60001F9")]
+		[Address(RVA = "0x2B34410", Offset = "0x2B33210", VA = "0x182B34410", Slot = "16")]
+		protected virtual void Transform(byte[] input, byte[] output)
+		{
+		}
+
+		// Token: 0x060001FA RID: 506
+		[Token(Token = "0x60001FA")]
+		[Address(Slot = "17")]
+		protected abstract void ECB(byte[] input, byte[] output);
+
+		// Token: 0x060001FB RID: 507 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60001FB")]
+		[Address(RVA = "0x2B32F10", Offset = "0x2B31D10", VA = "0x182B32F10", Slot = "18")]
+		protected virtual void CBC(byte[] input, byte[] output)
+		{
+		}
+
+		// Token: 0x060001FC RID: 508 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60001FC")]
+		[Address(RVA = "0x2B33090", Offset = "0x2B31E90", VA = "0x182B33090", Slot = "19")]
+		protected virtual void CFB(byte[] input, byte[] output)
+		{
+		}
+
+		// Token: 0x060001FD RID: 509 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60001FD")]
+		[Address(RVA = "0x2B33DE0", Offset = "0x2B32BE0", VA = "0x182B33DE0", Slot = "20")]
+		protected virtual void OFB(byte[] input, byte[] output)
+		{
+		}
+
+		// Token: 0x060001FE RID: 510 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60001FE")]
+		[Address(RVA = "0x2B332D0", Offset = "0x2B320D0", VA = "0x182B332D0", Slot = "21")]
+		protected virtual void CTS(byte[] input, byte[] output)
+		{
+		}
+
+		// Token: 0x060001FF RID: 511 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60001FF")]
+		[Address(RVA = "0x2B33330", Offset = "0x2B32130", VA = "0x182B33330")]
+		private void CheckInput(byte[] inputBuffer, int inputOffset, int inputCount)
+		{
+		}
+
+		// Token: 0x06000200 RID: 512 RVA: 0x00002E08 File Offset: 0x00001008
+		[Token(Token = "0x6000200")]
+		[Address(RVA = "0x2B340A0", Offset = "0x2B32EA0", VA = "0x182B340A0", Slot = "22")]
+		public virtual int TransformBlock(byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset)
+		{
+			return 0;
+		}
+
+		// Token: 0x17000054 RID: 84
+		// (get) Token: 0x06000201 RID: 513 RVA: 0x00002E20 File Offset: 0x00001020
+		[Token(Token = "0x17000054")]
+		private bool KeepLastBlock
+		{
+			[Token(Token = "0x6000201")]
+			[Address(RVA = "0x2B34950", Offset = "0x2B33750", VA = "0x182B34950")]
+			get
+			{
+				return default(bool);
+			}
+		}
+
+		// Token: 0x06000202 RID: 514 RVA: 0x00002E38 File Offset: 0x00001038
+		[Token(Token = "0x6000202")]
+		[Address(RVA = "0x2B33C00", Offset = "0x2B32A00", VA = "0x182B33C00")]
+		private int InternalTransformBlock(byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset)
+		{
+			return 0;
+		}
+
+		// Token: 0x06000203 RID: 515 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000203")]
+		[Address(RVA = "0x2B33E40", Offset = "0x2B32C40", VA = "0x182B33E40")]
+		private void Random(byte[] buffer, int start, int length)
+		{
+		}
+
+		// Token: 0x06000204 RID: 516 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000204")]
+		[Address(RVA = "0x2B33F70", Offset = "0x2B32D70", VA = "0x182B33F70")]
+		private void ThrowBadPaddingException(PaddingMode padding, int length, int position)
+		{
+		}
+
+		// Token: 0x06000205 RID: 517 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000205")]
+		[Address(RVA = "0x2B33830", Offset = "0x2B32630", VA = "0x182B33830", Slot = "23")]
+		protected virtual byte[] FinalEncrypt(byte[] inputBuffer, int inputOffset, int inputCount)
+		{
+			return null;
+		}
+
+		// Token: 0x06000206 RID: 518 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000206")]
+		[Address(RVA = "0x2B334E0", Offset = "0x2B322E0", VA = "0x182B334E0", Slot = "24")]
+		protected virtual byte[] FinalDecrypt(byte[] inputBuffer, int inputOffset, int inputCount)
+		{
+			return null;
+		}
+
+		// Token: 0x06000207 RID: 519 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000207")]
+		[Address(RVA = "0x2B34330", Offset = "0x2B33130", VA = "0x182B34330", Slot = "25")]
+		public virtual byte[] TransformFinalBlock(byte[] inputBuffer, int inputOffset, int inputCount)
+		{
+			return null;
+		}
+
+		// Token: 0x04000136 RID: 310
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x4000136")]
+		protected SymmetricAlgorithm algo;
+
+		// Token: 0x04000137 RID: 311
+		[FieldOffset(Offset = "0x18")]
+		[Token(Token = "0x4000137")]
+		protected bool encrypt;
+
+		// Token: 0x04000138 RID: 312
+		[FieldOffset(Offset = "0x1C")]
+		[Token(Token = "0x4000138")]
+		protected int BlockSizeByte;
+
+		// Token: 0x04000139 RID: 313
+		[FieldOffset(Offset = "0x20")]
+		[Token(Token = "0x4000139")]
+		protected byte[] temp;
+
+		// Token: 0x0400013A RID: 314
+		[FieldOffset(Offset = "0x28")]
+		[Token(Token = "0x400013A")]
+		protected byte[] temp2;
+
+		// Token: 0x0400013B RID: 315
+		[FieldOffset(Offset = "0x30")]
+		[Token(Token = "0x400013B")]
+		private byte[] workBuff;
+
+		// Token: 0x0400013C RID: 316
+		[FieldOffset(Offset = "0x38")]
+		[Token(Token = "0x400013C")]
+		private byte[] workout;
+
+		// Token: 0x0400013D RID: 317
+		[FieldOffset(Offset = "0x40")]
+		[Token(Token = "0x400013D")]
+		protected PaddingMode padmode;
+
+		// Token: 0x0400013E RID: 318
+		[FieldOffset(Offset = "0x44")]
+		[Token(Token = "0x400013E")]
+		protected int FeedBackByte;
+
+		// Token: 0x0400013F RID: 319
+		[FieldOffset(Offset = "0x48")]
+		[Token(Token = "0x400013F")]
+		private bool m_disposed;
+
+		// Token: 0x04000140 RID: 320
+		[FieldOffset(Offset = "0x49")]
+		[Token(Token = "0x4000140")]
+		protected bool lastBlock;
+
+		// Token: 0x04000141 RID: 321
+		[FieldOffset(Offset = "0x50")]
+		[Token(Token = "0x4000141")]
+		private RandomNumberGenerator _rng;
+	}
+}

mscorlib/Mono/Security/PKCS7.cs

@@ -0,0 +1,177 @@
+using System;
+using Cpp2IlInjected;
+
+namespace Mono.Security
+{
+	// Token: 0x02000031 RID: 49
+	[Token(Token = "0x2000031")]
+	internal sealed class PKCS7
+	{
+		// Token: 0x02000032 RID: 50
+		[Token(Token = "0x2000032")]
+		public class ContentInfo
+		{
+			// Token: 0x060000F2 RID: 242 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x60000F2")]
+			[Address(RVA = "0x2B20400", Offset = "0x2B1F200", VA = "0x182B20400")]
+			public ContentInfo()
+			{
+			}
+
+			// Token: 0x060000F3 RID: 243 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x60000F3")]
+			[Address(RVA = "0x2B201D0", Offset = "0x2B1EFD0", VA = "0x182B201D0")]
+			public ContentInfo(string oid)
+			{
+			}
+
+			// Token: 0x060000F4 RID: 244 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x60000F4")]
+			[Address(RVA = "0x2B20470", Offset = "0x2B1F270", VA = "0x182B20470")]
+			public ContentInfo(byte[] data)
+			{
+			}
+
+			// Token: 0x060000F5 RID: 245 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x60000F5")]
+			[Address(RVA = "0x2B20250", Offset = "0x2B1F050", VA = "0x182B20250")]
+			public ContentInfo(ASN1 asn1)
+			{
+			}
+
+			// Token: 0x17000018 RID: 24
+			// (get) Token: 0x060000F6 RID: 246 RVA: 0x00002082 File Offset: 0x00000282
+			[Token(Token = "0x17000018")]
+			public ASN1 ASN1
+			{
+				[Token(Token = "0x60000F6")]
+				[Address(RVA = "0x2B20120", Offset = "0x2B1EF20", VA = "0x182B20120")]
+				get
+				{
+					return null;
+				}
+			}
+
+			// Token: 0x17000019 RID: 25
+			// (get) Token: 0x060000F7 RID: 247 RVA: 0x00002082 File Offset: 0x00000282
+			// (set) Token: 0x060000F8 RID: 248 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x17000019")]
+			public ASN1 Content
+			{
+				[Token(Token = "0x60000F7")]
+				[Address(RVA = "0x3F5F40", Offset = "0x3F4D40", VA = "0x1803F5F40")]
+				get
+				{
+					return null;
+				}
+				[Token(Token = "0x60000F8")]
+				[Address(RVA = "0x3F7210", Offset = "0x3F6010", VA = "0x1803F7210")]
+				set
+				{
+				}
+			}
+
+			// Token: 0x1700001A RID: 26
+			// (get) Token: 0x060000F9 RID: 249 RVA: 0x00002082 File Offset: 0x00000282
+			// (set) Token: 0x060000FA RID: 250 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x1700001A")]
+			public string ContentType
+			{
+				[Token(Token = "0x60000F9")]
+				[Address(RVA = "0x3F6E20", Offset = "0x3F5C20", VA = "0x1803F6E20")]
+				get
+				{
+					return null;
+				}
+				[Token(Token = "0x60000FA")]
+				[Address(RVA = "0x3F7200", Offset = "0x3F6000", VA = "0x1803F7200")]
+				set
+				{
+				}
+			}
+
+			// Token: 0x060000FB RID: 251 RVA: 0x00002082 File Offset: 0x00000282
+			[Token(Token = "0x60000FB")]
+			[Address(RVA = "0x2B20120", Offset = "0x2B1EF20", VA = "0x182B20120")]
+			internal ASN1 GetASN1()
+			{
+				return null;
+			}
+
+			// Token: 0x040000BD RID: 189
+			[FieldOffset(Offset = "0x10")]
+			[Token(Token = "0x40000BD")]
+			private string contentType;
+
+			// Token: 0x040000BE RID: 190
+			[FieldOffset(Offset = "0x18")]
+			[Token(Token = "0x40000BE")]
+			private ASN1 content;
+		}
+
+		// Token: 0x02000033 RID: 51
+		[Token(Token = "0x2000033")]
+		public class EncryptedData
+		{
+			// Token: 0x060000FC RID: 252 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x60000FC")]
+			[Address(RVA = "0x637D50", Offset = "0x636B50", VA = "0x180637D50")]
+			public EncryptedData()
+			{
+			}
+
+			// Token: 0x060000FD RID: 253 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x60000FD")]
+			[Address(RVA = "0x2B25410", Offset = "0x2B24210", VA = "0x182B25410")]
+			public EncryptedData(ASN1 asn1)
+			{
+			}
+
+			// Token: 0x1700001B RID: 27
+			// (get) Token: 0x060000FE RID: 254 RVA: 0x00002082 File Offset: 0x00000282
+			[Token(Token = "0x1700001B")]
+			public PKCS7.ContentInfo EncryptionAlgorithm
+			{
+				[Token(Token = "0x60000FE")]
+				[Address(RVA = "0x3F6400", Offset = "0x3F5200", VA = "0x1803F6400")]
+				get
+				{
+					return null;
+				}
+			}
+
+			// Token: 0x1700001C RID: 28
+			// (get) Token: 0x060000FF RID: 255 RVA: 0x00002082 File Offset: 0x00000282
+			[Token(Token = "0x1700001C")]
+			public byte[] EncryptedContent
+			{
+				[Token(Token = "0x60000FF")]
+				[Address(RVA = "0x2B25760", Offset = "0x2B24560", VA = "0x182B25760")]
+				get
+				{
+					return null;
+				}
+			}
+
+			// Token: 0x040000BF RID: 191
+			[FieldOffset(Offset = "0x10")]
+			[Token(Token = "0x40000BF")]
+			private byte _version;
+
+			// Token: 0x040000C0 RID: 192
+			[FieldOffset(Offset = "0x18")]
+			[Token(Token = "0x40000C0")]
+			private PKCS7.ContentInfo _content;
+
+			// Token: 0x040000C1 RID: 193
+			[FieldOffset(Offset = "0x20")]
+			[Token(Token = "0x40000C1")]
+			private PKCS7.ContentInfo _encryptionAlgorithm;
+
+			// Token: 0x040000C2 RID: 194
+			[FieldOffset(Offset = "0x28")]
+			[Token(Token = "0x40000C2")]
+			private byte[] _encrypted;
+		}
+	}
+}

mscorlib/Mono/Security/X509/PKCS12.cs

@@ -0,0 +1,446 @@
+using System;
+using System.Collections;
+using System.Security.Cryptography;
+using Cpp2IlInjected;
+using Mono.Security.Cryptography;
+
+namespace Mono.Security.X509
+{
+	// Token: 0x02000035 RID: 53
+	[Token(Token = "0x2000035")]
+	internal class PKCS12 : ICloneable
+	{
+		// Token: 0x06000103 RID: 259 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000103")]
+		[Address(RVA = "0x2B2D260", Offset = "0x2B2C060", VA = "0x182B2D260")]
+		public PKCS12()
+		{
+		}
+
+		// Token: 0x06000104 RID: 260 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000104")]
+		[Address(RVA = "0x2B2D1A0", Offset = "0x2B2BFA0", VA = "0x182B2D1A0")]
+		public PKCS12(byte[] data)
+		{
+		}
+
+		// Token: 0x06000105 RID: 261 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000105")]
+		[Address(RVA = "0x2B2D210", Offset = "0x2B2C010", VA = "0x182B2D210")]
+		public PKCS12(byte[] data, string password)
+		{
+		}
+
+		// Token: 0x06000106 RID: 262 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000106")]
+		[Address(RVA = "0x2B29080", Offset = "0x2B27E80", VA = "0x182B29080")]
+		private void Decode(byte[] data)
+		{
+		}
+
+		// Token: 0x06000107 RID: 263 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000107")]
+		[Address(RVA = "0x2B29E90", Offset = "0x2B28C90", VA = "0x182B29E90", Slot = "1")]
+		protected override void Finalize()
+		{
+		}
+
+		// Token: 0x1700001F RID: 31
+		// (set) Token: 0x06000108 RID: 264 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x1700001F")]
+		public string Password
+		{
+			[Token(Token = "0x6000108")]
+			[Address(RVA = "0x2B2DD50", Offset = "0x2B2CB50", VA = "0x182B2DD50")]
+			set
+			{
+			}
+		}
+
+		// Token: 0x17000020 RID: 32
+		// (get) Token: 0x06000109 RID: 265 RVA: 0x00002940 File Offset: 0x00000B40
+		// (set) Token: 0x0600010A RID: 266 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x17000020")]
+		public int IterationCount
+		{
+			[Token(Token = "0x6000109")]
+			[Address(RVA = "0x436510", Offset = "0x435310", VA = "0x180436510")]
+			get
+			{
+				return 0;
+			}
+			[Token(Token = "0x600010A")]
+			[Address(RVA = "0x643C00", Offset = "0x642A00", VA = "0x180643C00")]
+			set
+			{
+			}
+		}
+
+		// Token: 0x17000021 RID: 33
+		// (get) Token: 0x0600010B RID: 267 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x17000021")]
+		public ArrayList Keys
+		{
+			[Token(Token = "0x600010B")]
+			[Address(RVA = "0x2B2D640", Offset = "0x2B2C440", VA = "0x182B2D640")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x17000022 RID: 34
+		// (get) Token: 0x0600010C RID: 268 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x17000022")]
+		public X509CertificateCollection Certificates
+		{
+			[Token(Token = "0x600010C")]
+			[Address(RVA = "0x2B2D330", Offset = "0x2B2C130", VA = "0x182B2D330")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x17000023 RID: 35
+		// (get) Token: 0x0600010D RID: 269 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x17000023")]
+		internal RandomNumberGenerator RNG
+		{
+			[Token(Token = "0x600010D")]
+			[Address(RVA = "0x643BD0", Offset = "0x6429D0", VA = "0x180643BD0")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x0600010E RID: 270 RVA: 0x00002958 File Offset: 0x00000B58
+		[Token(Token = "0x600010E")]
+		[Address(RVA = "0x63F060", Offset = "0x63DE60", VA = "0x18063F060")]
+		private bool Compare(byte[] expected, byte[] actual)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x0600010F RID: 271 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x600010F")]
+		[Address(RVA = "0x2B2BCD0", Offset = "0x2B2AAD0", VA = "0x182B2BCD0")]
+		private SymmetricAlgorithm GetSymmetricAlgorithm(string algorithmOid, byte[] salt, int iterationCount)
+		{
+			return null;
+		}
+
+		// Token: 0x06000110 RID: 272 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000110")]
+		[Address(RVA = "0x2B29810", Offset = "0x2B28610", VA = "0x182B29810")]
+		public byte[] Decrypt(string algorithmOid, byte[] salt, int iterationCount, byte[] encryptedData)
+		{
+			return null;
+		}
+
+		// Token: 0x06000111 RID: 273 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000111")]
+		[Address(RVA = "0x2B29940", Offset = "0x2B28740", VA = "0x182B29940")]
+		public byte[] Decrypt(PKCS7.EncryptedData ed)
+		{
+			return null;
+		}
+
+		// Token: 0x06000112 RID: 274 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000112")]
+		[Address(RVA = "0x2B29A70", Offset = "0x2B28870", VA = "0x182B29A70")]
+		public byte[] Encrypt(string algorithmOid, byte[] salt, int iterationCount, byte[] data)
+		{
+			return null;
+		}
+
+		// Token: 0x06000113 RID: 275 RVA: 0x00002970 File Offset: 0x00000B70
+		[Token(Token = "0x6000113")]
+		[Address(RVA = "0x2B2BA70", Offset = "0x2B2A870", VA = "0x182B2BA70")]
+		private DSAParameters GetExistingParameters(out bool found)
+		{
+			return default(DSAParameters);
+		}
+
+		// Token: 0x06000114 RID: 276 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000114")]
+		[Address(RVA = "0x2B28610", Offset = "0x2B27410", VA = "0x182B28610")]
+		private void AddPrivateKey(PKCS8.PrivateKeyInfo pki)
+		{
+		}
+
+		// Token: 0x06000115 RID: 277 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000115")]
+		[Address(RVA = "0x2B2C570", Offset = "0x2B2B370", VA = "0x182B2C570")]
+		private void ReadSafeBag(ASN1 safeBag)
+		{
+		}
+
+		// Token: 0x06000116 RID: 278 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000116")]
+		[Address(RVA = "0x2B28780", Offset = "0x2B27580", VA = "0x182B28780")]
+		private ASN1 CertificateSafeBag(X509Certificate x509, IDictionary attributes)
+		{
+			return null;
+		}
+
+		// Token: 0x06000117 RID: 279 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000117")]
+		[Address(RVA = "0x2B2C3D0", Offset = "0x2B2B1D0", VA = "0x182B2C3D0")]
+		private byte[] MAC(byte[] password, byte[] salt, int iterations, byte[] data)
+		{
+			return null;
+		}
+
+		// Token: 0x06000118 RID: 280 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000118")]
+		[Address(RVA = "0x2B29F20", Offset = "0x2B28D20", VA = "0x182B29F20")]
+		public byte[] GetBytes()
+		{
+			return null;
+		}
+
+		// Token: 0x06000119 RID: 281 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000119")]
+		[Address(RVA = "0x2B29BA0", Offset = "0x2B289A0", VA = "0x182B29BA0")]
+		private PKCS7.ContentInfo EncryptedContentInfo(ASN1 safeBags, string algorithmOid)
+		{
+			return null;
+		}
+
+		// Token: 0x0600011A RID: 282 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600011A")]
+		[Address(RVA = "0x2B28360", Offset = "0x2B27160", VA = "0x182B28360")]
+		public void AddCertificate(X509Certificate cert)
+		{
+		}
+
+		// Token: 0x0600011B RID: 283 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600011B")]
+		[Address(RVA = "0x2B28370", Offset = "0x2B27170", VA = "0x182B28370")]
+		public void AddCertificate(X509Certificate cert, IDictionary attributes)
+		{
+		}
+
+		// Token: 0x0600011C RID: 284 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600011C")]
+		[Address(RVA = "0x2B2CC70", Offset = "0x2B2BA70", VA = "0x182B2CC70")]
+		public void RemoveCertificate(X509Certificate cert)
+		{
+		}
+
+		// Token: 0x0600011D RID: 285 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600011D")]
+		[Address(RVA = "0x2B2CC80", Offset = "0x2B2BA80", VA = "0x182B2CC80")]
+		public void RemoveCertificate(X509Certificate cert, IDictionary attrs)
+		{
+		}
+
+		// Token: 0x0600011E RID: 286 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x600011E")]
+		[Address(RVA = "0x2B28F50", Offset = "0x2B27D50", VA = "0x182B28F50", Slot = "4")]
+		public object Clone()
+		{
+			return null;
+		}
+
+		// Token: 0x17000024 RID: 36
+		// (get) Token: 0x0600011F RID: 287 RVA: 0x00002988 File Offset: 0x00000B88
+		[Token(Token = "0x17000024")]
+		public static int MaximumPasswordLength
+		{
+			[Token(Token = "0x600011F")]
+			[Address(RVA = "0x2B2DC90", Offset = "0x2B2CA90", VA = "0x182B2DC90")]
+			get
+			{
+				return 0;
+			}
+		}
+
+		// Token: 0x040000C5 RID: 197
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x40000C5")]
+		private byte[] _password;
+
+		// Token: 0x040000C6 RID: 198
+		[FieldOffset(Offset = "0x18")]
+		[Token(Token = "0x40000C6")]
+		private ArrayList _keyBags;
+
+		// Token: 0x040000C7 RID: 199
+		[FieldOffset(Offset = "0x20")]
+		[Token(Token = "0x40000C7")]
+		private ArrayList _secretBags;
+
+		// Token: 0x040000C8 RID: 200
+		[FieldOffset(Offset = "0x28")]
+		[Token(Token = "0x40000C8")]
+		private X509CertificateCollection _certs;
+
+		// Token: 0x040000C9 RID: 201
+		[FieldOffset(Offset = "0x30")]
+		[Token(Token = "0x40000C9")]
+		private bool _keyBagsChanged;
+
+		// Token: 0x040000CA RID: 202
+		[FieldOffset(Offset = "0x31")]
+		[Token(Token = "0x40000CA")]
+		private bool _secretBagsChanged;
+
+		// Token: 0x040000CB RID: 203
+		[FieldOffset(Offset = "0x32")]
+		[Token(Token = "0x40000CB")]
+		private bool _certsChanged;
+
+		// Token: 0x040000CC RID: 204
+		[FieldOffset(Offset = "0x34")]
+		[Token(Token = "0x40000CC")]
+		private int _iterations;
+
+		// Token: 0x040000CD RID: 205
+		[FieldOffset(Offset = "0x38")]
+		[Token(Token = "0x40000CD")]
+		private ArrayList _safeBags;
+
+		// Token: 0x040000CE RID: 206
+		[FieldOffset(Offset = "0x40")]
+		[Token(Token = "0x40000CE")]
+		private RandomNumberGenerator _rng;
+
+		// Token: 0x040000CF RID: 207
+		[Token(Token = "0x40000CF")]
+		private static int password_max_length;
+
+		// Token: 0x02000036 RID: 54
+		[Token(Token = "0x2000036")]
+		public class DeriveBytes
+		{
+			// Token: 0x06000121 RID: 289 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6000121")]
+			[Address(RVA = "0x3F5100", Offset = "0x3F3F00", VA = "0x1803F5100")]
+			public DeriveBytes()
+			{
+			}
+
+			// Token: 0x17000025 RID: 37
+			// (set) Token: 0x06000122 RID: 290 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x17000025")]
+			public string HashName
+			{
+				[Token(Token = "0x6000122")]
+				[Address(RVA = "0x3F7200", Offset = "0x3F6000", VA = "0x1803F7200")]
+				set
+				{
+				}
+			}
+
+			// Token: 0x17000026 RID: 38
+			// (set) Token: 0x06000123 RID: 291 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x17000026")]
+			public int IterationCount
+			{
+				[Token(Token = "0x6000123")]
+				[Address(RVA = "0x41F740", Offset = "0x41E540", VA = "0x18041F740")]
+				set
+				{
+				}
+			}
+
+			// Token: 0x17000027 RID: 39
+			// (set) Token: 0x06000124 RID: 292 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x17000027")]
+			public byte[] Password
+			{
+				[Token(Token = "0x6000124")]
+				[Address(RVA = "0x2B252E0", Offset = "0x2B240E0", VA = "0x182B252E0")]
+				set
+				{
+				}
+			}
+
+			// Token: 0x17000028 RID: 40
+			// (set) Token: 0x06000125 RID: 293 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x17000028")]
+			public byte[] Salt
+			{
+				[Token(Token = "0x6000125")]
+				[Address(RVA = "0x2B25380", Offset = "0x2B24180", VA = "0x182B25380")]
+				set
+				{
+				}
+			}
+
+			// Token: 0x06000126 RID: 294 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6000126")]
+			[Address(RVA = "0x6370C0", Offset = "0x635EC0", VA = "0x1806370C0")]
+			private void Adjust(byte[] a, int aOff, byte[] b)
+			{
+			}
+
+			// Token: 0x06000127 RID: 295 RVA: 0x00002082 File Offset: 0x00000282
+			[Token(Token = "0x6000127")]
+			[Address(RVA = "0x2B24D50", Offset = "0x2B23B50", VA = "0x182B24D50")]
+			private byte[] Derive(byte[] diversifier, int n)
+			{
+				return null;
+			}
+
+			// Token: 0x06000128 RID: 296 RVA: 0x00002082 File Offset: 0x00000282
+			[Token(Token = "0x6000128")]
+			[Address(RVA = "0x2B24C50", Offset = "0x2B23A50", VA = "0x182B24C50")]
+			public byte[] DeriveKey(int size)
+			{
+				return null;
+			}
+
+			// Token: 0x06000129 RID: 297 RVA: 0x00002082 File Offset: 0x00000282
+			[Token(Token = "0x6000129")]
+			[Address(RVA = "0x2B24BD0", Offset = "0x2B239D0", VA = "0x182B24BD0")]
+			public byte[] DeriveIV(int size)
+			{
+				return null;
+			}
+
+			// Token: 0x0600012A RID: 298 RVA: 0x00002082 File Offset: 0x00000282
+			[Token(Token = "0x600012A")]
+			[Address(RVA = "0x2B24CD0", Offset = "0x2B23AD0", VA = "0x182B24CD0")]
+			public byte[] DeriveMAC(int size)
+			{
+				return null;
+			}
+
+			// Token: 0x040000D0 RID: 208
+			[Token(Token = "0x40000D0")]
+			private static byte[] keyDiversifier;
+
+			// Token: 0x040000D1 RID: 209
+			[Token(Token = "0x40000D1")]
+			private static byte[] ivDiversifier;
+
+			// Token: 0x040000D2 RID: 210
+			[Token(Token = "0x40000D2")]
+			private static byte[] macDiversifier;
+
+			// Token: 0x040000D3 RID: 211
+			[FieldOffset(Offset = "0x10")]
+			[Token(Token = "0x40000D3")]
+			private string _hashName;
+
+			// Token: 0x040000D4 RID: 212
+			[FieldOffset(Offset = "0x18")]
+			[Token(Token = "0x40000D4")]
+			private int _iterations;
+
+			// Token: 0x040000D5 RID: 213
+			[FieldOffset(Offset = "0x20")]
+			[Token(Token = "0x40000D5")]
+			private byte[] _password;
+
+			// Token: 0x040000D6 RID: 214
+			[FieldOffset(Offset = "0x28")]
+			[Token(Token = "0x40000D6")]
+			private byte[] _salt;
+		}
+	}
+}

mscorlib/Mono/Security/X509/SafeBag.cs

@@ -0,0 +1,53 @@
+using System;
+using Cpp2IlInjected;
+
+namespace Mono.Security.X509
+{
+	// Token: 0x02000034 RID: 52
+	[Token(Token = "0x2000034")]
+	internal class SafeBag
+	{
+		// Token: 0x06000100 RID: 256 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000100")]
+		[Address(RVA = "0x4089A0", Offset = "0x4077A0", VA = "0x1804089A0")]
+		public SafeBag(string bagOID, ASN1 asn1)
+		{
+		}
+
+		// Token: 0x1700001D RID: 29
+		// (get) Token: 0x06000101 RID: 257 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x1700001D")]
+		public string BagOID
+		{
+			[Token(Token = "0x6000101")]
+			[Address(RVA = "0x3F6E20", Offset = "0x3F5C20", VA = "0x1803F6E20")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x1700001E RID: 30
+		// (get) Token: 0x06000102 RID: 258 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x1700001E")]
+		public ASN1 ASN1
+		{
+			[Token(Token = "0x6000102")]
+			[Address(RVA = "0x3F5F40", Offset = "0x3F4D40", VA = "0x1803F5F40")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x040000C3 RID: 195
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x40000C3")]
+		private string _bagOID;
+
+		// Token: 0x040000C4 RID: 196
+		[FieldOffset(Offset = "0x18")]
+		[Token(Token = "0x40000C4")]
+		private ASN1 _asn1;
+	}
+}

mscorlib/Mono/Security/X509/X501.cs

@@ -0,0 +1,94 @@
+using System;
+using System.Text;
+using Cpp2IlInjected;
+
+namespace Mono.Security.X509
+{
+	// Token: 0x02000037 RID: 55
+	[Token(Token = "0x2000037")]
+	internal sealed class X501
+	{
+		// Token: 0x0600012C RID: 300 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x600012C")]
+		[Address(RVA = "0x26D2D50", Offset = "0x26D1B50", VA = "0x1826D2D50")]
+		public static string ToString(ASN1 seq)
+		{
+			return null;
+		}
+
+		// Token: 0x0600012D RID: 301 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x600012D")]
+		[Address(RVA = "0x26D2BA0", Offset = "0x26D19A0", VA = "0x1826D2BA0")]
+		public static string ToString(ASN1 seq, bool reversed, string separator, bool quotes)
+		{
+			return null;
+		}
+
+		// Token: 0x0600012E RID: 302 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600012E")]
+		[Address(RVA = "0x26D2380", Offset = "0x26D1180", VA = "0x1826D2380")]
+		private static void AppendEntry(StringBuilder sb, ASN1 entry, bool quotes)
+		{
+		}
+
+		// Token: 0x040000D7 RID: 215
+		[Token(Token = "0x40000D7")]
+		private static byte[] countryName;
+
+		// Token: 0x040000D8 RID: 216
+		[Token(Token = "0x40000D8")]
+		private static byte[] organizationName;
+
+		// Token: 0x040000D9 RID: 217
+		[Token(Token = "0x40000D9")]
+		private static byte[] organizationalUnitName;
+
+		// Token: 0x040000DA RID: 218
+		[Token(Token = "0x40000DA")]
+		private static byte[] commonName;
+
+		// Token: 0x040000DB RID: 219
+		[Token(Token = "0x40000DB")]
+		private static byte[] localityName;
+
+		// Token: 0x040000DC RID: 220
+		[Token(Token = "0x40000DC")]
+		private static byte[] stateOrProvinceName;
+
+		// Token: 0x040000DD RID: 221
+		[Token(Token = "0x40000DD")]
+		private static byte[] streetAddress;
+
+		// Token: 0x040000DE RID: 222
+		[Token(Token = "0x40000DE")]
+		private static byte[] domainComponent;
+
+		// Token: 0x040000DF RID: 223
+		[Token(Token = "0x40000DF")]
+		private static byte[] userid;
+
+		// Token: 0x040000E0 RID: 224
+		[Token(Token = "0x40000E0")]
+		private static byte[] email;
+
+		// Token: 0x040000E1 RID: 225
+		[Token(Token = "0x40000E1")]
+		private static byte[] dnQualifier;
+
+		// Token: 0x040000E2 RID: 226
+		[Token(Token = "0x40000E2")]
+		private static byte[] title;
+
+		// Token: 0x040000E3 RID: 227
+		[Token(Token = "0x40000E3")]
+		private static byte[] surname;
+
+		// Token: 0x040000E4 RID: 228
+		[Token(Token = "0x40000E4")]
+		private static byte[] givenName;
+
+		// Token: 0x040000E5 RID: 229
+		[Token(Token = "0x40000E5")]
+		private static byte[] initial;
+	}
+}

mscorlib/Mono/Security/X509/X509Certificate.cs

@@ -0,0 +1,304 @@
+using System;
+using System.Runtime.Serialization;
+using System.Security.Cryptography;
+using Cpp2IlInjected;
+
+namespace Mono.Security.X509
+{
+	// Token: 0x02000038 RID: 56
+	[Token(Token = "0x2000038")]
+	internal class X509Certificate : ISerializable
+	{
+		// Token: 0x06000130 RID: 304 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000130")]
+		[Address(RVA = "0x26D3810", Offset = "0x26D2610", VA = "0x1826D3810")]
+		private void Parse(byte[] data)
+		{
+		}
+
+		// Token: 0x06000131 RID: 305 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000131")]
+		[Address(RVA = "0x26D4050", Offset = "0x26D2E50", VA = "0x1826D4050")]
+		public X509Certificate(byte[] data)
+		{
+		}
+
+		// Token: 0x06000132 RID: 306 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000132")]
+		[Address(RVA = "0x26D3650", Offset = "0x26D2450", VA = "0x1826D3650")]
+		private byte[] GetUnsignedBigInteger(byte[] integer)
+		{
+			return null;
+		}
+
+		// Token: 0x17000029 RID: 41
+		// (get) Token: 0x06000133 RID: 307 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x17000029")]
+		public DSA DSA
+		{
+			[Token(Token = "0x6000133")]
+			[Address(RVA = "0x26D4280", Offset = "0x26D3080", VA = "0x1826D4280")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x1700002A RID: 42
+		// (get) Token: 0x06000134 RID: 308 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x1700002A")]
+		public virtual string IssuerName
+		{
+			[Token(Token = "0x6000134")]
+			[Address(RVA = "0x3F63D0", Offset = "0x3F51D0", VA = "0x1803F63D0", Slot = "5")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x1700002B RID: 43
+		// (get) Token: 0x06000135 RID: 309 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x1700002B")]
+		public virtual byte[] KeyAlgorithmParameters
+		{
+			[Token(Token = "0x6000135")]
+			[Address(RVA = "0x26D4590", Offset = "0x26D3390", VA = "0x1826D4590", Slot = "6")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x1700002C RID: 44
+		// (get) Token: 0x06000136 RID: 310 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x1700002C")]
+		public virtual byte[] PublicKey
+		{
+			[Token(Token = "0x6000136")]
+			[Address(RVA = "0x26D4610", Offset = "0x26D3410", VA = "0x1826D4610", Slot = "7")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x1700002D RID: 45
+		// (get) Token: 0x06000137 RID: 311 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x1700002D")]
+		public virtual RSA RSA
+		{
+			[Token(Token = "0x6000137")]
+			[Address(RVA = "0x26D4690", Offset = "0x26D3490", VA = "0x1826D4690", Slot = "8")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x1700002E RID: 46
+		// (get) Token: 0x06000138 RID: 312 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x1700002E")]
+		public virtual byte[] RawData
+		{
+			[Token(Token = "0x6000138")]
+			[Address(RVA = "0x26D4870", Offset = "0x26D3670", VA = "0x1826D4870", Slot = "9")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x1700002F RID: 47
+		// (get) Token: 0x06000139 RID: 313 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x1700002F")]
+		public virtual byte[] SerialNumber
+		{
+			[Token(Token = "0x6000139")]
+			[Address(RVA = "0x26D48F0", Offset = "0x26D36F0", VA = "0x1826D48F0", Slot = "10")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x17000030 RID: 48
+		// (get) Token: 0x0600013A RID: 314 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x17000030")]
+		public virtual string SubjectName
+		{
+			[Token(Token = "0x600013A")]
+			[Address(RVA = "0x423D40", Offset = "0x422B40", VA = "0x180423D40", Slot = "11")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x17000031 RID: 49
+		// (get) Token: 0x0600013B RID: 315 RVA: 0x000029A0 File Offset: 0x00000BA0
+		[Token(Token = "0x17000031")]
+		public virtual DateTime ValidFrom
+		{
+			[Token(Token = "0x600013B")]
+			[Address(RVA = "0x3F6400", Offset = "0x3F5200", VA = "0x1803F6400", Slot = "12")]
+			get
+			{
+				return default(DateTime);
+			}
+		}
+
+		// Token: 0x17000032 RID: 50
+		// (get) Token: 0x0600013C RID: 316 RVA: 0x000029B8 File Offset: 0x00000BB8
+		[Token(Token = "0x17000032")]
+		public virtual DateTime ValidUntil
+		{
+			[Token(Token = "0x600013C")]
+			[Address(RVA = "0x3F63E0", Offset = "0x3F51E0", VA = "0x1803F63E0", Slot = "13")]
+			get
+			{
+				return default(DateTime);
+			}
+		}
+
+		// Token: 0x0600013D RID: 317 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x600013D")]
+		[Address(RVA = "0x3FA180", Offset = "0x3F8F80", VA = "0x1803FA180")]
+		public ASN1 GetIssuerName()
+		{
+			return null;
+		}
+
+		// Token: 0x0600013E RID: 318 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x600013E")]
+		[Address(RVA = "0x415290", Offset = "0x414090", VA = "0x180415290")]
+		public ASN1 GetSubjectName()
+		{
+			return null;
+		}
+
+		// Token: 0x0600013F RID: 319 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600013F")]
+		[Address(RVA = "0x26D35F0", Offset = "0x26D23F0", VA = "0x1826D35F0", Slot = "14")]
+		public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
+		{
+		}
+
+		// Token: 0x06000140 RID: 320 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000140")]
+		[Address(RVA = "0x26D3700", Offset = "0x26D2500", VA = "0x1826D3700")]
+		private static byte[] PEM(string type, byte[] data)
+		{
+			return null;
+		}
+
+		// Token: 0x040000E6 RID: 230
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x40000E6")]
+		private ASN1 decoder;
+
+		// Token: 0x040000E7 RID: 231
+		[FieldOffset(Offset = "0x18")]
+		[Token(Token = "0x40000E7")]
+		private byte[] m_encodedcert;
+
+		// Token: 0x040000E8 RID: 232
+		[FieldOffset(Offset = "0x20")]
+		[Token(Token = "0x40000E8")]
+		private DateTime m_from;
+
+		// Token: 0x040000E9 RID: 233
+		[FieldOffset(Offset = "0x28")]
+		[Token(Token = "0x40000E9")]
+		private DateTime m_until;
+
+		// Token: 0x040000EA RID: 234
+		[FieldOffset(Offset = "0x30")]
+		[Token(Token = "0x40000EA")]
+		private ASN1 issuer;
+
+		// Token: 0x040000EB RID: 235
+		[FieldOffset(Offset = "0x38")]
+		[Token(Token = "0x40000EB")]
+		private string m_issuername;
+
+		// Token: 0x040000EC RID: 236
+		[FieldOffset(Offset = "0x40")]
+		[Token(Token = "0x40000EC")]
+		private string m_keyalgo;
+
+		// Token: 0x040000ED RID: 237
+		[FieldOffset(Offset = "0x48")]
+		[Token(Token = "0x40000ED")]
+		private byte[] m_keyalgoparams;
+
+		// Token: 0x040000EE RID: 238
+		[FieldOffset(Offset = "0x50")]
+		[Token(Token = "0x40000EE")]
+		private ASN1 subject;
+
+		// Token: 0x040000EF RID: 239
+		[FieldOffset(Offset = "0x58")]
+		[Token(Token = "0x40000EF")]
+		private string m_subject;
+
+		// Token: 0x040000F0 RID: 240
+		[FieldOffset(Offset = "0x60")]
+		[Token(Token = "0x40000F0")]
+		private byte[] m_publickey;
+
+		// Token: 0x040000F1 RID: 241
+		[FieldOffset(Offset = "0x68")]
+		[Token(Token = "0x40000F1")]
+		private byte[] signature;
+
+		// Token: 0x040000F2 RID: 242
+		[FieldOffset(Offset = "0x70")]
+		[Token(Token = "0x40000F2")]
+		private string m_signaturealgo;
+
+		// Token: 0x040000F3 RID: 243
+		[FieldOffset(Offset = "0x78")]
+		[Token(Token = "0x40000F3")]
+		private byte[] m_signaturealgoparams;
+
+		// Token: 0x040000F4 RID: 244
+		[FieldOffset(Offset = "0x80")]
+		[Token(Token = "0x40000F4")]
+		private RSA _rsa;
+
+		// Token: 0x040000F5 RID: 245
+		[FieldOffset(Offset = "0x88")]
+		[Token(Token = "0x40000F5")]
+		private DSA _dsa;
+
+		// Token: 0x040000F6 RID: 246
+		[FieldOffset(Offset = "0x90")]
+		[Token(Token = "0x40000F6")]
+		private int version;
+
+		// Token: 0x040000F7 RID: 247
+		[FieldOffset(Offset = "0x98")]
+		[Token(Token = "0x40000F7")]
+		private byte[] serialnumber;
+
+		// Token: 0x040000F8 RID: 248
+		[FieldOffset(Offset = "0xA0")]
+		[Token(Token = "0x40000F8")]
+		private byte[] issuerUniqueID;
+
+		// Token: 0x040000F9 RID: 249
+		[FieldOffset(Offset = "0xA8")]
+		[Token(Token = "0x40000F9")]
+		private byte[] subjectUniqueID;
+
+		// Token: 0x040000FA RID: 250
+		[FieldOffset(Offset = "0xB0")]
+		[Token(Token = "0x40000FA")]
+		private X509ExtensionCollection extensions;
+
+		// Token: 0x040000FB RID: 251
+		[Token(Token = "0x40000FB")]
+		private static string encoding_error;
+	}
+}

mscorlib/Mono/Security/X509/X509CertificateCollection.cs

@@ -0,0 +1,129 @@
+using System;
+using System.Collections;
+using Cpp2IlInjected;
+
+namespace Mono.Security.X509
+{
+	// Token: 0x02000039 RID: 57
+	[Token(Token = "0x2000039")]
+	[Serializable]
+	internal class X509CertificateCollection : CollectionBase, IEnumerable
+	{
+		// Token: 0x06000142 RID: 322 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000142")]
+		[Address(RVA = "0x5174E0", Offset = "0x5162E0", VA = "0x1805174E0")]
+		public X509CertificateCollection()
+		{
+		}
+
+		// Token: 0x17000033 RID: 51
+		[Token(Token = "0x17000033")]
+		public X509Certificate this[int index]
+		{
+			[Token(Token = "0x6000143")]
+			[Address(RVA = "0x26D3300", Offset = "0x26D2100", VA = "0x1826D3300")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x06000144 RID: 324 RVA: 0x000029D0 File Offset: 0x00000BD0
+		[Token(Token = "0x6000144")]
+		[Address(RVA = "0x26D31D0", Offset = "0x26D1FD0", VA = "0x1826D31D0")]
+		public int Add(X509Certificate value)
+		{
+			return 0;
+		}
+
+		// Token: 0x06000145 RID: 325 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000145")]
+		[Address(RVA = "0x26D3270", Offset = "0x26D2070", VA = "0x1826D3270")]
+		public new X509CertificateCollection.X509CertificateEnumerator GetEnumerator()
+		{
+			return null;
+		}
+
+		// Token: 0x06000146 RID: 326 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000146")]
+		[Address(RVA = "0x73DEB0", Offset = "0x73CCB0", VA = "0x18073DEB0", Slot = "19")]
+		IEnumerator IEnumerable.GetEnumerator()
+		{
+			return null;
+		}
+
+		// Token: 0x06000147 RID: 327 RVA: 0x000029E8 File Offset: 0x00000BE8
+		[Token(Token = "0x6000147")]
+		[Address(RVA = "0x51A580", Offset = "0x519380", VA = "0x18051A580", Slot = "2")]
+		public override int GetHashCode()
+		{
+			return 0;
+		}
+
+		// Token: 0x0200003A RID: 58
+		[Token(Token = "0x200003A")]
+		public class X509CertificateEnumerator : IEnumerator
+		{
+			// Token: 0x06000148 RID: 328 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6000148")]
+			[Address(RVA = "0x26D34F0", Offset = "0x26D22F0", VA = "0x1826D34F0")]
+			public X509CertificateEnumerator(X509CertificateCollection mappings)
+			{
+			}
+
+			// Token: 0x17000034 RID: 52
+			// (get) Token: 0x06000149 RID: 329 RVA: 0x00002082 File Offset: 0x00000282
+			[Token(Token = "0x17000034")]
+			public X509Certificate Current
+			{
+				[Token(Token = "0x6000149")]
+				[Address(RVA = "0x26D3550", Offset = "0x26D2350", VA = "0x1826D3550")]
+				get
+				{
+					return null;
+				}
+			}
+
+			// Token: 0x17000035 RID: 53
+			// (get) Token: 0x0600014A RID: 330 RVA: 0x00002082 File Offset: 0x00000282
+			[Token(Token = "0x17000035")]
+			object IEnumerator.Current
+			{
+				[Token(Token = "0x600014A")]
+				[Address(RVA = "0x26D34A0", Offset = "0x26D22A0", VA = "0x1826D34A0", Slot = "5")]
+				get
+				{
+					return null;
+				}
+			}
+
+			// Token: 0x0600014B RID: 331 RVA: 0x00002A00 File Offset: 0x00000C00
+			[Token(Token = "0x600014B")]
+			[Address(RVA = "0x26D3400", Offset = "0x26D2200", VA = "0x1826D3400", Slot = "4")]
+			bool IEnumerator.MoveNext()
+			{
+				return default(bool);
+			}
+
+			// Token: 0x0600014C RID: 332 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x600014C")]
+			[Address(RVA = "0x26D3450", Offset = "0x26D2250", VA = "0x1826D3450", Slot = "6")]
+			void IEnumerator.Reset()
+			{
+			}
+
+			// Token: 0x0600014D RID: 333 RVA: 0x00002A18 File Offset: 0x00000C18
+			[Token(Token = "0x600014D")]
+			[Address(RVA = "0x26D33B0", Offset = "0x26D21B0", VA = "0x1826D33B0")]
+			public bool MoveNext()
+			{
+				return default(bool);
+			}
+
+			// Token: 0x040000FC RID: 252
+			[FieldOffset(Offset = "0x10")]
+			[Token(Token = "0x40000FC")]
+			private IEnumerator enumerator;
+		}
+	}
+}

mscorlib/Mono/Security/X509/X509Extension.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Text;
+using Cpp2IlInjected;
+
+namespace Mono.Security.X509
+{
+	// Token: 0x0200003B RID: 59
+	[Token(Token = "0x200003B")]
+	internal class X509Extension
+	{
+		// Token: 0x0600014E RID: 334 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600014E")]
+		[Address(RVA = "0x26D4F20", Offset = "0x26D3D20", VA = "0x1826D4F20")]
+		public X509Extension(ASN1 asn1)
+		{
+		}
+
+		// Token: 0x0600014F RID: 335 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600014F")]
+		[Address(RVA = "0x402080", Offset = "0x400E80", VA = "0x180402080", Slot = "4")]
+		protected virtual void Decode()
+		{
+		}
+
+		// Token: 0x06000150 RID: 336 RVA: 0x00002A30 File Offset: 0x00000C30
+		[Token(Token = "0x6000150")]
+		[Address(RVA = "0x26D4A90", Offset = "0x26D3890", VA = "0x1826D4A90", Slot = "0")]
+		public override bool Equals(object obj)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x06000151 RID: 337 RVA: 0x00002A48 File Offset: 0x00000C48
+		[Token(Token = "0x6000151")]
+		[Address(RVA = "0x4DA700", Offset = "0x4D9500", VA = "0x1804DA700", Slot = "2")]
+		public override int GetHashCode()
+		{
+			return 0;
+		}
+
+		// Token: 0x06000152 RID: 338 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000152")]
+		[Address(RVA = "0x26D4D00", Offset = "0x26D3B00", VA = "0x1826D4D00")]
+		private void WriteLine(StringBuilder sb, int n, int pos)
+		{
+		}
+
+		// Token: 0x06000153 RID: 339 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000153")]
+		[Address(RVA = "0x26D4BE0", Offset = "0x26D39E0", VA = "0x1826D4BE0", Slot = "3")]
+		public override string ToString()
+		{
+			return null;
+		}
+
+		// Token: 0x040000FD RID: 253
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x40000FD")]
+		protected string extnOid;
+
+		// Token: 0x040000FE RID: 254
+		[FieldOffset(Offset = "0x18")]
+		[Token(Token = "0x40000FE")]
+		protected bool extnCritical;
+
+		// Token: 0x040000FF RID: 255
+		[FieldOffset(Offset = "0x20")]
+		[Token(Token = "0x40000FF")]
+		protected ASN1 extnValue;
+	}
+}

mscorlib/Mono/Security/X509/X509ExtensionCollection.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Collections;
+using System.Reflection;
+using Cpp2IlInjected;
+
+namespace Mono.Security.X509
+{
+	// Token: 0x0200003C RID: 60
+	[Token(Token = "0x200003C")]
+	[DefaultMember("Item")]
+	internal sealed class X509ExtensionCollection : CollectionBase, IEnumerable
+	{
+		// Token: 0x06000154 RID: 340 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000154")]
+		[Address(RVA = "0x5174E0", Offset = "0x5162E0", VA = "0x1805174E0")]
+		public X509ExtensionCollection()
+		{
+		}
+
+		// Token: 0x06000155 RID: 341 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000155")]
+		[Address(RVA = "0x26D4970", Offset = "0x26D3770", VA = "0x1826D4970")]
+		public X509ExtensionCollection(ASN1 asn1)
+		{
+		}
+
+		// Token: 0x06000156 RID: 342 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000156")]
+		[Address(RVA = "0x73DEB0", Offset = "0x73CCB0", VA = "0x18073DEB0", Slot = "19")]
+		IEnumerator IEnumerable.GetEnumerator()
+		{
+			return null;
+		}
+
+		// Token: 0x04000100 RID: 256
+		[FieldOffset(Offset = "0x18")]
+		[Token(Token = "0x4000100")]
+		private bool readOnly;
+	}
+}

mscorlib/Mono/Xml/SecurityParser.cs

@@ -0,0 +1,98 @@
+using System;
+using System.Collections;
+using System.Security;
+using Cpp2IlInjected;
+
+namespace Mono.Xml
+{
+	// Token: 0x02000018 RID: 24
+	[Token(Token = "0x2000018")]
+	internal class SecurityParser : SmallXmlParser, SmallXmlParser.IContentHandler
+	{
+		// Token: 0x0600003A RID: 58 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600003A")]
+		[Address(RVA = "0x26CE310", Offset = "0x26CD110", VA = "0x1826CE310")]
+		public SecurityParser()
+		{
+		}
+
+		// Token: 0x0600003B RID: 59 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600003B")]
+		[Address(RVA = "0x26CDFC0", Offset = "0x26CCDC0", VA = "0x1826CDFC0")]
+		public void LoadXml(string xml)
+		{
+		}
+
+		// Token: 0x0600003C RID: 60 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x600003C")]
+		[Address(RVA = "0x423E10", Offset = "0x422C10", VA = "0x180423E10")]
+		public SecurityElement ToXml()
+		{
+			return null;
+		}
+
+		// Token: 0x0600003D RID: 61 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600003D")]
+		[Address(RVA = "0x402080", Offset = "0x400E80", VA = "0x180402080", Slot = "4")]
+		public void OnStartParsing(SmallXmlParser parser)
+		{
+		}
+
+		// Token: 0x0600003E RID: 62 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600003E")]
+		[Address(RVA = "0x402080", Offset = "0x400E80", VA = "0x180402080", Slot = "8")]
+		public void OnProcessingInstruction(string name, string text)
+		{
+		}
+
+		// Token: 0x0600003F RID: 63 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600003F")]
+		[Address(RVA = "0x402080", Offset = "0x400E80", VA = "0x180402080", Slot = "10")]
+		public void OnIgnorableWhitespace(string s)
+		{
+		}
+
+		// Token: 0x06000040 RID: 64 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000040")]
+		[Address(RVA = "0x26CE160", Offset = "0x26CCF60", VA = "0x1826CE160", Slot = "6")]
+		public void OnStartElement(string name, SmallXmlParser.IAttrList attrs)
+		{
+		}
+
+		// Token: 0x06000041 RID: 65 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000041")]
+		[Address(RVA = "0x26CE0E0", Offset = "0x26CCEE0", VA = "0x1826CE0E0", Slot = "7")]
+		public void OnEndElement(string name)
+		{
+		}
+
+		// Token: 0x06000042 RID: 66 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000042")]
+		[Address(RVA = "0x26CE060", Offset = "0x26CCE60", VA = "0x1826CE060", Slot = "9")]
+		public void OnChars(string ch)
+		{
+		}
+
+		// Token: 0x06000043 RID: 67 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000043")]
+		[Address(RVA = "0x402080", Offset = "0x400E80", VA = "0x180402080", Slot = "5")]
+		public void OnEndParsing(SmallXmlParser parser)
+		{
+		}
+
+		// Token: 0x0400003A RID: 58
+		[FieldOffset(Offset = "0x68")]
+		[Token(Token = "0x400003A")]
+		private SecurityElement root;
+
+		// Token: 0x0400003B RID: 59
+		[FieldOffset(Offset = "0x70")]
+		[Token(Token = "0x400003B")]
+		private SecurityElement current;
+
+		// Token: 0x0400003C RID: 60
+		[FieldOffset(Offset = "0x78")]
+		[Token(Token = "0x400003C")]
+		private Stack stack;
+	}
+}

mscorlib/Mono/Xml/SmallXmlParser.cs

@@ -0,0 +1,433 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using Cpp2IlInjected;
+
+namespace Mono.Xml
+{
+	// Token: 0x02000019 RID: 25
+	[Token(Token = "0x2000019")]
+	internal class SmallXmlParser
+	{
+		// Token: 0x06000044 RID: 68 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000044")]
+		[Address(RVA = "0x26D0680", Offset = "0x26CF480", VA = "0x1826D0680")]
+		public SmallXmlParser()
+		{
+		}
+
+		// Token: 0x06000045 RID: 69 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000045")]
+		[Address(RVA = "0x26CE630", Offset = "0x26CD430", VA = "0x1826CE630")]
+		private Exception Error(string msg)
+		{
+			return null;
+		}
+
+		// Token: 0x06000046 RID: 70 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000046")]
+		[Address(RVA = "0x26D05C0", Offset = "0x26CF3C0", VA = "0x1826D05C0")]
+		private Exception UnexpectedEndError()
+		{
+			return null;
+		}
+
+		// Token: 0x06000047 RID: 71 RVA: 0x000022C8 File Offset: 0x000004C8
+		[Token(Token = "0x6000047")]
+		[Address(RVA = "0x26CEA10", Offset = "0x26CD810", VA = "0x1826CEA10")]
+		private bool IsNameChar(char c, bool start)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x06000048 RID: 72 RVA: 0x000022E0 File Offset: 0x000004E0
+		[Token(Token = "0x6000048")]
+		[Address(RVA = "0x26CEBB0", Offset = "0x26CD9B0", VA = "0x1826CEBB0")]
+		private bool IsWhitespace(int c)
+		{
+			return default(bool);
+		}
+
+		// Token: 0x06000049 RID: 73 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000049")]
+		[Address(RVA = "0x26D05B0", Offset = "0x26CF3B0", VA = "0x1826D05B0")]
+		public void SkipWhitespaces()
+		{
+		}
+
+		// Token: 0x0600004A RID: 74 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600004A")]
+		[Address(RVA = "0x26CE900", Offset = "0x26CD700", VA = "0x1826CE900")]
+		private void HandleWhitespaces()
+		{
+		}
+
+		// Token: 0x0600004B RID: 75 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600004B")]
+		[Address(RVA = "0x26D04C0", Offset = "0x26CF2C0", VA = "0x1826D04C0")]
+		public void SkipWhitespaces(bool expected)
+		{
+		}
+
+		// Token: 0x0600004C RID: 76 RVA: 0x000022F8 File Offset: 0x000004F8
+		[Token(Token = "0x600004C")]
+		[Address(RVA = "0x260E040", Offset = "0x260CE40", VA = "0x18260E040")]
+		private int Peek()
+		{
+			return 0;
+		}
+
+		// Token: 0x0600004D RID: 77 RVA: 0x00002310 File Offset: 0x00000510
+		[Token(Token = "0x600004D")]
+		[Address(RVA = "0x26D0460", Offset = "0x26CF260", VA = "0x1826D0460")]
+		private int Read()
+		{
+			return 0;
+		}
+
+		// Token: 0x0600004E RID: 78 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600004E")]
+		[Address(RVA = "0x26CE710", Offset = "0x26CD510", VA = "0x1826CE710")]
+		public void Expect(int c)
+		{
+		}
+
+		// Token: 0x0600004F RID: 79 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x600004F")]
+		[Address(RVA = "0x26D0300", Offset = "0x26CF100", VA = "0x1826D0300")]
+		private string ReadUntil(char until, bool handleReferences)
+		{
+			return null;
+		}
+
+		// Token: 0x06000050 RID: 80 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000050")]
+		[Address(RVA = "0x26CFEF0", Offset = "0x26CECF0", VA = "0x1826CFEF0")]
+		public string ReadName()
+		{
+			return null;
+		}
+
+		// Token: 0x06000051 RID: 81 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000051")]
+		[Address(RVA = "0x26CEBD0", Offset = "0x26CD9D0", VA = "0x1826CEBD0")]
+		public void Parse(TextReader input, SmallXmlParser.IContentHandler handler)
+		{
+		}
+
+		// Token: 0x06000052 RID: 82 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000052")]
+		[Address(RVA = "0x26CE550", Offset = "0x26CD350", VA = "0x1826CE550")]
+		private void Cleanup()
+		{
+		}
+
+		// Token: 0x06000053 RID: 83 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000053")]
+		[Address(RVA = "0x26CF530", Offset = "0x26CE330", VA = "0x1826CF530")]
+		public void ReadContent()
+		{
+		}
+
+		// Token: 0x06000054 RID: 84 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000054")]
+		[Address(RVA = "0x26CE830", Offset = "0x26CD630", VA = "0x1826CE830")]
+		private void HandleBufferedContent()
+		{
+		}
+
+		// Token: 0x06000055 RID: 85 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000055")]
+		[Address(RVA = "0x26CF2B0", Offset = "0x26CE0B0", VA = "0x1826CF2B0")]
+		private void ReadCharacters()
+		{
+		}
+
+		// Token: 0x06000056 RID: 86 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000056")]
+		[Address(RVA = "0x26D00E0", Offset = "0x26CEEE0", VA = "0x1826D00E0")]
+		private void ReadReference()
+		{
+		}
+
+		// Token: 0x06000057 RID: 87 RVA: 0x00002328 File Offset: 0x00000528
+		[Token(Token = "0x6000057")]
+		[Address(RVA = "0x26CF100", Offset = "0x26CDF00", VA = "0x1826CF100")]
+		private int ReadCharacterReference()
+		{
+			return 0;
+		}
+
+		// Token: 0x06000058 RID: 88 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000058")]
+		[Address(RVA = "0x26CEDE0", Offset = "0x26CDBE0", VA = "0x1826CEDE0")]
+		private void ReadAttribute(SmallXmlParser.AttrListImpl a)
+		{
+		}
+
+		// Token: 0x06000059 RID: 89 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000059")]
+		[Address(RVA = "0x26CEF80", Offset = "0x26CDD80", VA = "0x1826CEF80")]
+		private void ReadCDATASection()
+		{
+		}
+
+		// Token: 0x0600005A RID: 90 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600005A")]
+		[Address(RVA = "0x26CF3D0", Offset = "0x26CE1D0", VA = "0x1826CF3D0")]
+		private void ReadComment()
+		{
+		}
+
+		// Token: 0x0400003D RID: 61
+		[FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x400003D")]
+		private SmallXmlParser.IContentHandler handler;
+
+		// Token: 0x0400003E RID: 62
+		[FieldOffset(Offset = "0x18")]
+		[Token(Token = "0x400003E")]
+		private TextReader reader;
+
+		// Token: 0x0400003F RID: 63
+		[FieldOffset(Offset = "0x20")]
+		[Token(Token = "0x400003F")]
+		private Stack elementNames;
+
+		// Token: 0x04000040 RID: 64
+		[FieldOffset(Offset = "0x28")]
+		[Token(Token = "0x4000040")]
+		private Stack xmlSpaces;
+
+		// Token: 0x04000041 RID: 65
+		[FieldOffset(Offset = "0x30")]
+		[Token(Token = "0x4000041")]
+		private string xmlSpace;
+
+		// Token: 0x04000042 RID: 66
+		[FieldOffset(Offset = "0x38")]
+		[Token(Token = "0x4000042")]
+		private StringBuilder buffer;
+
+		// Token: 0x04000043 RID: 67
+		[FieldOffset(Offset = "0x40")]
+		[Token(Token = "0x4000043")]
+		private char[] nameBuffer;
+
+		// Token: 0x04000044 RID: 68
+		[FieldOffset(Offset = "0x48")]
+		[Token(Token = "0x4000044")]
+		private bool isWhitespace;
+
+		// Token: 0x04000045 RID: 69
+		[FieldOffset(Offset = "0x50")]
+		[Token(Token = "0x4000045")]
+		private SmallXmlParser.AttrListImpl attributes;
+
+		// Token: 0x04000046 RID: 70
+		[FieldOffset(Offset = "0x58")]
+		[Token(Token = "0x4000046")]
+		private int line;
+
+		// Token: 0x04000047 RID: 71
+		[FieldOffset(Offset = "0x5C")]
+		[Token(Token = "0x4000047")]
+		private int column;
+
+		// Token: 0x04000048 RID: 72
+		[FieldOffset(Offset = "0x60")]
+		[Token(Token = "0x4000048")]
+		private bool resetColumn;
+
+		// Token: 0x0200001A RID: 26
+		[Token(Token = "0x200001A")]
+		public interface IContentHandler
+		{
+			// Token: 0x0600005B RID: 91
+			[Token(Token = "0x600005B")]
+			[Address(Slot = "0")]
+			void OnStartParsing(SmallXmlParser parser);
+
+			// Token: 0x0600005C RID: 92
+			[Token(Token = "0x600005C")]
+			[Address(Slot = "1")]
+			void OnEndParsing(SmallXmlParser parser);
+
+			// Token: 0x0600005D RID: 93
+			[Token(Token = "0x600005D")]
+			[Address(Slot = "2")]
+			void OnStartElement(string name, SmallXmlParser.IAttrList attrs);
+
+			// Token: 0x0600005E RID: 94
+			[Token(Token = "0x600005E")]
+			[Address(Slot = "3")]
+			void OnEndElement(string name);
+
+			// Token: 0x0600005F RID: 95
+			[Token(Token = "0x600005F")]
+			[Address(Slot = "4")]
+			void OnProcessingInstruction(string name, string text);
+
+			// Token: 0x06000060 RID: 96
+			[Token(Token = "0x6000060")]
+			[Address(Slot = "5")]
+			void OnChars(string text);
+
+			// Token: 0x06000061 RID: 97
+			[Token(Token = "0x6000061")]
+			[Address(Slot = "6")]
+			void OnIgnorableWhitespace(string text);
+		}
+
+		// Token: 0x0200001B RID: 27
+		[Token(Token = "0x200001B")]
+		public interface IAttrList
+		{
+			// Token: 0x1700000C RID: 12
+			// (get) Token: 0x06000062 RID: 98
+			[Token(Token = "0x1700000C")]
+			int Length
+			{
+				[Token(Token = "0x6000062")]
+				[Address(Slot = "0")]
+				get;
+			}
+
+			// Token: 0x06000063 RID: 99
+			[Token(Token = "0x6000063")]
+			[Address(Slot = "1")]
+			string GetName(int i);
+
+			// Token: 0x06000064 RID: 100
+			[Token(Token = "0x6000064")]
+			[Address(Slot = "2")]
+			string GetValue(int i);
+
+			// Token: 0x06000065 RID: 101
+			[Token(Token = "0x6000065")]
+			[Address(Slot = "3")]
+			string GetValue(string name);
+
+			// Token: 0x1700000D RID: 13
+			// (get) Token: 0x06000066 RID: 102
+			[Token(Token = "0x1700000D")]
+			string[] Names
+			{
+				[Token(Token = "0x6000066")]
+				[Address(Slot = "4")]
+				get;
+			}
+
+			// Token: 0x1700000E RID: 14
+			// (get) Token: 0x06000067 RID: 103
+			[Token(Token = "0x1700000E")]
+			string[] Values
+			{
+				[Token(Token = "0x6000067")]
+				[Address(Slot = "5")]
+				get;
+			}
+		}
+
+		// Token: 0x0200001C RID: 28
+		[Token(Token = "0x200001C")]
+		private class AttrListImpl : SmallXmlParser.IAttrList
+		{
+			// Token: 0x1700000F RID: 15
+			// (get) Token: 0x06000068 RID: 104 RVA: 0x00002340 File Offset: 0x00000540
+			[Token(Token = "0x1700000F")]
+			public int Length
+			{
+				[Token(Token = "0x6000068")]
+				[Address(RVA = "0x26C5190", Offset = "0x26C3F90", VA = "0x1826C5190", Slot = "4")]
+				get
+				{
+					return 0;
+				}
+			}
+
+			// Token: 0x06000069 RID: 105 RVA: 0x00002082 File Offset: 0x00000282
+			[Token(Token = "0x6000069")]
+			[Address(RVA = "0x26C4F70", Offset = "0x26C3D70", VA = "0x1826C4F70", Slot = "5")]
+			public string GetName(int i)
+			{
+				return null;
+			}
+
+			// Token: 0x0600006A RID: 106 RVA: 0x00002082 File Offset: 0x00000282
+			[Token(Token = "0x600006A")]
+			[Address(RVA = "0x26C4FD0", Offset = "0x26C3DD0", VA = "0x1826C4FD0", Slot = "6")]
+			public string GetValue(int i)
+			{
+				return null;
+			}
+
+			// Token: 0x0600006B RID: 107 RVA: 0x00002082 File Offset: 0x00000282
+			[Token(Token = "0x600006B")]
+			[Address(RVA = "0x26C5030", Offset = "0x26C3E30", VA = "0x1826C5030", Slot = "7")]
+			public string GetValue(string name)
+			{
+				return null;
+			}
+
+			// Token: 0x17000010 RID: 16
+			// (get) Token: 0x0600006C RID: 108 RVA: 0x00002082 File Offset: 0x00000282
+			[Token(Token = "0x17000010")]
+			public string[] Names
+			{
+				[Token(Token = "0x600006C")]
+				[Address(RVA = "0x26C51D0", Offset = "0x26C3FD0", VA = "0x1826C51D0", Slot = "8")]
+				get
+				{
+					return null;
+				}
+			}
+
+			// Token: 0x17000011 RID: 17
+			// (get) Token: 0x0600006D RID: 109 RVA: 0x00002082 File Offset: 0x00000282
+			[Token(Token = "0x17000011")]
+			public string[] Values
+			{
+				[Token(Token = "0x600006D")]
+				[Address(RVA = "0x26C5220", Offset = "0x26C4020", VA = "0x1826C5220", Slot = "9")]
+				get
+				{
+					return null;
+				}
+			}
+
+			// Token: 0x0600006E RID: 110 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x600006E")]
+			[Address(RVA = "0x26C4F10", Offset = "0x26C3D10", VA = "0x1826C4F10")]
+			internal void Clear()
+			{
+			}
+
+			// Token: 0x0600006F RID: 111 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x600006F")]
+			[Address(RVA = "0x26C4E90", Offset = "0x26C3C90", VA = "0x1826C4E90")]
+			internal void Add(string name, string value)
+			{
+			}
+
+			// Token: 0x06000070 RID: 112 RVA: 0x00002050 File Offset: 0x00000250
+			[Token(Token = "0x6000070")]
+			[Address(RVA = "0x26C5110", Offset = "0x26C3F10", VA = "0x1826C5110")]
+			public AttrListImpl()
+			{
+			}
+
+			// Token: 0x04000049 RID: 73
+			[FieldOffset(Offset = "0x10")]
+			[Token(Token = "0x4000049")]
+			private List<string> attrNames;
+
+			// Token: 0x0400004A RID: 74
+			[FieldOffset(Offset = "0x18")]
+			[Token(Token = "0x400004A")]
+			private List<string> attrValues;
+		}
+	}
+}

mscorlib/Mono/Xml/SmallXmlParserException.cs

@@ -0,0 +1,27 @@
+using System;
+using Cpp2IlInjected;
+
+namespace Mono.Xml
+{
+	// Token: 0x0200001D RID: 29
+	[Token(Token = "0x200001D")]
+	internal class SmallXmlParserException : SystemException
+	{
+		// Token: 0x06000071 RID: 113 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000071")]
+		[Address(RVA = "0x26CE490", Offset = "0x26CD290", VA = "0x1826CE490")]
+		public SmallXmlParserException(string msg, int line, int column)
+		{
+		}
+
+		// Token: 0x0400004B RID: 75
+		[FieldOffset(Offset = "0x88")]
+		[Token(Token = "0x400004B")]
+		private int line;
+
+		// Token: 0x0400004C RID: 76
+		[FieldOffset(Offset = "0x8C")]
+		[Token(Token = "0x400004C")]
+		private int column;
+	}
+}

mscorlib/Properties/AssemblyInfo.cs

@@ -0,0 +1,4 @@
+using System;
+using System.Reflection;
+
+[assembly: AssemblyVersion("4.0.0.0")]

mscorlib/SR.cs

@@ -0,0 +1,23 @@
+using System;
+using Cpp2IlInjected;
+
+// Token: 0x02000004 RID: 4
+[Token(Token = "0x2000004")]
+internal static class SR
+{
+	// Token: 0x06000007 RID: 7 RVA: 0x00002082 File Offset: 0x00000282
+	[Token(Token = "0x6000007")]
+	[Address(RVA = "0x26CDF50", Offset = "0x26CCD50", VA = "0x1826CDF50")]
+	internal static string Format(string resourceFormat, object p1)
+	{
+		return null;
+	}
+
+	// Token: 0x06000008 RID: 8 RVA: 0x00002082 File Offset: 0x00000282
+	[Token(Token = "0x6000008")]
+	[Address(RVA = "0x26CDEC0", Offset = "0x26CCCC0", VA = "0x1826CDEC0")]
+	internal static string Format(string resourceFormat, object p1, object p2)
+	{
+		return null;
+	}
+}

mscorlib/System/Action.2.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Runtime.CompilerServices;
+using Cpp2IlInjected;
+
+namespace System
+{
+	/// <summary>Encapsulates a method that has no parameters and does not return a value.</summary>
+	// Token: 0x02000098 RID: 152
+	// (Invoke) Token: 0x0600048A RID: 1162
+	[Token(Token = "0x2000098")]
+	[TypeForwardedFrom("System.Core, Version=2.0.5.0, Culture=Neutral, PublicKeyToken=7cec85d7bea7798e")]
+	public delegate void Action();
+}

mscorlib/System/Action.3.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Runtime.CompilerServices;
+using Cpp2IlInjected;
+
+namespace System
+{
+	/// <summary>Encapsulates a method that has two parameters and does not return a value.</summary>
+	/// <param name="arg1">The first parameter of the method that this delegate encapsulates.</param>
+	/// <param name="arg2">The second parameter of the method that this delegate encapsulates.</param>
+	/// <typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam>
+	/// <typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam>
+	// Token: 0x02000099 RID: 153
+	// (Invoke) Token: 0x0600048E RID: 1166
+	[Token(Token = "0x2000099")]
+	[TypeForwardedFrom("System.Core, Version=2.0.5.0, Culture=Neutral, PublicKeyToken=7cec85d7bea7798e")]
+	public delegate void Action<in T1, in T2>(T1 arg1, T2 arg2);
+}

mscorlib/System/Action.4.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Runtime.CompilerServices;
+using Cpp2IlInjected;
+
+namespace System
+{
+	/// <summary>Encapsulates a method that has three parameters and does not return a value.</summary>
+	/// <param name="arg1">The first parameter of the method that this delegate encapsulates.</param>
+	/// <param name="arg2">The second parameter of the method that this delegate encapsulates.</param>
+	/// <param name="arg3">The third parameter of the method that this delegate encapsulates.</param>
+	/// <typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam>
+	/// <typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam>
+	/// <typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam>
+	// Token: 0x0200009A RID: 154
+	// (Invoke) Token: 0x06000492 RID: 1170
+	[Token(Token = "0x200009A")]
+	[TypeForwardedFrom("System.Core, Version=2.0.5.0, Culture=Neutral, PublicKeyToken=7cec85d7bea7798e")]
+	public delegate void Action<in T1, in T2, in T3>(T1 arg1, T2 arg2, T3 arg3);
+}

mscorlib/System/Action.5.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Runtime.CompilerServices;
+using Cpp2IlInjected;
+
+namespace System
+{
+	/// <summary>Encapsulates a method that has four parameters and does not return a value.</summary>
+	/// <param name="arg1">The first parameter of the method that this delegate encapsulates.</param>
+	/// <param name="arg2">The second parameter of the method that this delegate encapsulates.</param>
+	/// <param name="arg3">The third parameter of the method that this delegate encapsulates.</param>
+	/// <param name="arg4">The fourth parameter of the method that this delegate encapsulates.</param>
+	/// <typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam>
+	/// <typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam>
+	/// <typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam>
+	/// <typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam>
+	// Token: 0x0200009B RID: 155
+	// (Invoke) Token: 0x06000496 RID: 1174
+	[Token(Token = "0x200009B")]
+	[TypeForwardedFrom("System.Core, Version=2.0.5.0, Culture=Neutral, PublicKeyToken=7cec85d7bea7798e")]
+	public delegate void Action<in T1, in T2, in T3, in T4>(T1 arg1, T2 arg2, T3 arg3, T4 arg4);
+}

mscorlib/System/Action.6.cs

@@ -0,0 +1,21 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System
+{
+	/// <summary>Encapsulates a method that has five parameters and does not return a value.</summary>
+	/// <param name="arg1">The first parameter of the method that this delegate encapsulates.</param>
+	/// <param name="arg2">The second parameter of the method that this delegate encapsulates.</param>
+	/// <param name="arg3">The third parameter of the method that this delegate encapsulates.</param>
+	/// <param name="arg4">The fourth parameter of the method that this delegate encapsulates.</param>
+	/// <param name="arg5">The fifth parameter of the method that this delegate encapsulates.</param>
+	/// <typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam>
+	/// <typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam>
+	/// <typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam>
+	/// <typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam>
+	/// <typeparam name="T5">The type of the fifth parameter of the method that this delegate encapsulates.</typeparam>
+	// Token: 0x020000A1 RID: 161
+	// (Invoke) Token: 0x060004AE RID: 1198
+	[Token(Token = "0x20000A1")]
+	public delegate void Action<in T1, in T2, in T3, in T4, in T5>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5);
+}

mscorlib/System/Action.7.cs

@@ -0,0 +1,23 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System
+{
+	/// <summary>Encapsulates a method that has six parameters and does not return a value.</summary>
+	/// <param name="arg1">The first parameter of the method that this delegate encapsulates.</param>
+	/// <param name="arg2">The second parameter of the method that this delegate encapsulates.</param>
+	/// <param name="arg3">The third parameter of the method that this delegate encapsulates.</param>
+	/// <param name="arg4">The fourth parameter of the method that this delegate encapsulates.</param>
+	/// <param name="arg5">The fifth parameter of the method that this delegate encapsulates.</param>
+	/// <param name="arg6">The sixth parameter of the method that this delegate encapsulates.</param>
+	/// <typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam>
+	/// <typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam>
+	/// <typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam>
+	/// <typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam>
+	/// <typeparam name="T5">The type of the fifth parameter of the method that this delegate encapsulates.</typeparam>
+	/// <typeparam name="T6">The type of the sixth parameter of the method that this delegate encapsulates.</typeparam>
+	// Token: 0x020000A2 RID: 162
+	// (Invoke) Token: 0x060004B2 RID: 1202
+	[Token(Token = "0x20000A2")]
+	public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6);
+}

mscorlib/System/Action.8.cs

@@ -0,0 +1,25 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System
+{
+	/// <summary>Encapsulates a method that has seven parameters and does not return a value.</summary>
+	/// <param name="arg1">The first parameter of the method that this delegate encapsulates.</param>
+	/// <param name="arg2">The second parameter of the method that this delegate encapsulates.</param>
+	/// <param name="arg3">The third parameter of the method that this delegate encapsulates.</param>
+	/// <param name="arg4">The fourth parameter of the method that this delegate encapsulates.</param>
+	/// <param name="arg5">The fifth parameter of the method that this delegate encapsulates.</param>
+	/// <param name="arg6">The sixth parameter of the method that this delegate encapsulates.</param>
+	/// <param name="arg7">The seventh parameter of the method that this delegate encapsulates.</param>
+	/// <typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam>
+	/// <typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam>
+	/// <typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam>
+	/// <typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam>
+	/// <typeparam name="T5">The type of the fifth parameter of the method that this delegate encapsulates.</typeparam>
+	/// <typeparam name="T6">The type of the sixth parameter of the method that this delegate encapsulates.</typeparam>
+	/// <typeparam name="T7">The type of the seventh parameter of the method that this delegate encapsulates.</typeparam>
+	// Token: 0x020000A3 RID: 163
+	// (Invoke) Token: 0x060004B6 RID: 1206
+	[Token(Token = "0x20000A3")]
+	public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7);
+}

mscorlib/System/Action.9.cs

@@ -0,0 +1,27 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System
+{
+	/// <summary>Encapsulates a method that has eight parameters and does not return a value.</summary>
+	/// <param name="arg1">The first parameter of the method that this delegate encapsulates.</param>
+	/// <param name="arg2">The second parameter of the method that this delegate encapsulates.</param>
+	/// <param name="arg3">The third parameter of the method that this delegate encapsulates.</param>
+	/// <param name="arg4">The fourth parameter of the method that this delegate encapsulates.</param>
+	/// <param name="arg5">The fifth parameter of the method that this delegate encapsulates.</param>
+	/// <param name="arg6">The sixth parameter of the method that this delegate encapsulates.</param>
+	/// <param name="arg7">The seventh parameter of the method that this delegate encapsulates.</param>
+	/// <param name="arg8">The eighth parameter of the method that this delegate encapsulates.</param>
+	/// <typeparam name="T1">The type of the first parameter of the method that this delegate encapsulates.</typeparam>
+	/// <typeparam name="T2">The type of the second parameter of the method that this delegate encapsulates.</typeparam>
+	/// <typeparam name="T3">The type of the third parameter of the method that this delegate encapsulates.</typeparam>
+	/// <typeparam name="T4">The type of the fourth parameter of the method that this delegate encapsulates.</typeparam>
+	/// <typeparam name="T5">The type of the fifth parameter of the method that this delegate encapsulates.</typeparam>
+	/// <typeparam name="T6">The type of the sixth parameter of the method that this delegate encapsulates.</typeparam>
+	/// <typeparam name="T7">The type of the seventh parameter of the method that this delegate encapsulates.</typeparam>
+	/// <typeparam name="T8">The type of the eighth parameter of the method that this delegate encapsulates.</typeparam>
+	// Token: 0x020000A4 RID: 164
+	// (Invoke) Token: 0x060004BA RID: 1210
+	[Token(Token = "0x20000A4")]
+	public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8);
+}

mscorlib/System/Action.cs

@@ -0,0 +1,13 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System
+{
+	/// <summary>Encapsulates a method that has a single parameter and does not return a value.</summary>
+	/// <param name="obj">The parameter of the method that this delegate encapsulates.</param>
+	/// <typeparam name="T">The type of the parameter of the method that this delegate encapsulates.</typeparam>
+	// Token: 0x02000097 RID: 151
+	// (Invoke) Token: 0x06000486 RID: 1158
+	[Token(Token = "0x2000097")]
+	public delegate void Action<in T>(T obj);
+}

mscorlib/System/Activator.cs

@@ -0,0 +1,235 @@
+using System;
+using System.Globalization;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using Cpp2IlInjected;
+
+namespace System
+{
+	/// <summary>Contains methods to create types of objects locally or remotely, or obtain references to existing remote objects. This class cannot be inherited.</summary>
+	// Token: 0x020000AC RID: 172
+	[Token(Token = "0x20000AC")]
+	[ComDefaultInterface(typeof(_Activator))]
+	[ClassInterface(ClassInterfaceType.None)]
+	[ComVisible(true)]
+	public sealed class Activator
+	{
+		/// <summary>Creates an instance of the specified type using the constructor that best matches the specified parameters.</summary>
+		/// <param name="type">The type of object to create.</param>
+		/// <param name="bindingAttr">A combination of zero or more bit flags that affect the search for the <paramref name="type" /> constructor. If <paramref name="bindingAttr" /> is zero, a case-sensitive search for public constructors is conducted.</param>
+		/// <param name="binder">An object that uses <paramref name="bindingAttr" /> and <paramref name="args" /> to seek and identify the <paramref name="type" /> constructor. If <paramref name="binder" /> is <see langword="null" />, the default binder is used.</param>
+		/// <param name="args">An array of arguments that match in number, order, and type the parameters of the constructor to invoke. If <paramref name="args" /> is an empty array or <see langword="null" />, the constructor that takes no parameters (the default constructor) is invoked.</param>
+		/// <param name="culture">Culture-specific information that governs the coercion of <paramref name="args" /> to the formal types declared for the <paramref name="type" /> constructor. If <paramref name="culture" /> is <see langword="null" />, the <see cref="T:System.Globalization.CultureInfo" /> for the current thread is used.</param>
+		/// <returns>A reference to the newly created object.</returns>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="type" /> is <see langword="null" />.</exception>
+		/// <exception cref="T:System.ArgumentException">
+		///   <paramref name="type" /> is not a <see langword="RuntimeType" />.  
+		/// -or-  
+		/// <paramref name="type" /> is an open generic type (that is, the <see cref="P:System.Type.ContainsGenericParameters" /> property returns <see langword="true" />).</exception>
+		/// <exception cref="T:System.NotSupportedException">
+		///   <paramref name="type" /> cannot be a <see cref="T:System.Reflection.Emit.TypeBuilder" />.  
+		/// -or-  
+		/// Creation of <see cref="T:System.TypedReference" />, <see cref="T:System.ArgIterator" />, <see cref="T:System.Void" />, and <see cref="T:System.RuntimeArgumentHandle" /> types, or arrays of those types, is not supported.  
+		/// -or-  
+		/// The assembly that contains <paramref name="type" /> is a dynamic assembly that was created with <see cref="F:System.Reflection.Emit.AssemblyBuilderAccess.Save" />.  
+		/// -or-  
+		/// The constructor that best matches <paramref name="args" /> has <see langword="varargs" /> arguments.</exception>
+		/// <exception cref="T:System.Reflection.TargetInvocationException">The constructor being called throws an exception.</exception>
+		/// <exception cref="T:System.MethodAccessException">The caller does not have permission to call this constructor.</exception>
+		/// <exception cref="T:System.MemberAccessException">Cannot create an instance of an abstract class, or this member was invoked with a late-binding mechanism.</exception>
+		/// <exception cref="T:System.Runtime.InteropServices.InvalidComObjectException">The COM type was not obtained through <see cref="Overload:System.Type.GetTypeFromProgID" /> or <see cref="Overload:System.Type.GetTypeFromCLSID" />.</exception>
+		/// <exception cref="T:System.MissingMethodException">No matching constructor was found.</exception>
+		/// <exception cref="T:System.Runtime.InteropServices.COMException">
+		///   <paramref name="type" /> is a COM object but the class identifier used to obtain the type is invalid, or the identified class is not registered.</exception>
+		/// <exception cref="T:System.TypeLoadException">
+		///   <paramref name="type" /> is not a valid type.</exception>
+		// Token: 0x060004D9 RID: 1241 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60004D9")]
+		[Address(RVA = "0x26BBE30", Offset = "0x26BAC30", VA = "0x1826BBE30")]
+		public static object CreateInstance(Type type, BindingFlags bindingAttr, Binder binder, object[] args, CultureInfo culture)
+		{
+			return null;
+		}
+
+		/// <summary>Creates an instance of the specified type using the constructor that best matches the specified parameters.</summary>
+		/// <param name="type">The type of object to create.</param>
+		/// <param name="bindingAttr">A combination of zero or more bit flags that affect the search for the <paramref name="type" /> constructor. If <paramref name="bindingAttr" /> is zero, a case-sensitive search for public constructors is conducted.</param>
+		/// <param name="binder">An object that uses <paramref name="bindingAttr" /> and <paramref name="args" /> to seek and identify the <paramref name="type" /> constructor. If <paramref name="binder" /> is <see langword="null" />, the default binder is used.</param>
+		/// <param name="args">An array of arguments that match in number, order, and type the parameters of the constructor to invoke. If <paramref name="args" /> is an empty array or <see langword="null" />, the constructor that takes no parameters (the default constructor) is invoked.</param>
+		/// <param name="culture">Culture-specific information that governs the coercion of <paramref name="args" /> to the formal types declared for the <paramref name="type" /> constructor. If <paramref name="culture" /> is <see langword="null" />, the <see cref="T:System.Globalization.CultureInfo" /> for the current thread is used.</param>
+		/// <param name="activationAttributes">An array of one or more attributes that can participate in activation. This is typically an array that contains a single <see cref="T:System.Runtime.Remoting.Activation.UrlAttribute" /> object that specifies the URL that is required to activate a remote object.  
+		///  This parameter is related to client-activated objects. Client activation is a legacy technology that is retained for backward compatibility but is not recommended for new development. Distributed applications should instead use Windows Communication Foundation.</param>
+		/// <returns>A reference to the newly created object.</returns>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="type" /> is <see langword="null" />.</exception>
+		/// <exception cref="T:System.ArgumentException">
+		///   <paramref name="type" /> is not a <see langword="RuntimeType" />.  
+		/// -or-  
+		/// <paramref name="type" /> is an open generic type (that is, the <see cref="P:System.Type.ContainsGenericParameters" /> property returns <see langword="true" />).</exception>
+		/// <exception cref="T:System.NotSupportedException">
+		///   <paramref name="type" /> cannot be a <see cref="T:System.Reflection.Emit.TypeBuilder" />.  
+		/// -or-  
+		/// Creation of <see cref="T:System.TypedReference" />, <see cref="T:System.ArgIterator" />, <see cref="T:System.Void" />, and <see cref="T:System.RuntimeArgumentHandle" /> types, or arrays of those types, is not supported.  
+		/// -or-  
+		/// <paramref name="activationAttributes" /> is not an empty array, and the type being created does not derive from <see cref="T:System.MarshalByRefObject" />.  
+		/// -or-  
+		/// The assembly that contains <paramref name="type" /> is a dynamic assembly that was created with <see cref="F:System.Reflection.Emit.AssemblyBuilderAccess.Save" />.  
+		/// -or-  
+		/// The constructor that best matches <paramref name="args" /> has <see langword="varargs" /> arguments.</exception>
+		/// <exception cref="T:System.Reflection.TargetInvocationException">The constructor being called throws an exception.</exception>
+		/// <exception cref="T:System.MethodAccessException">The caller does not have permission to call this constructor.</exception>
+		/// <exception cref="T:System.MemberAccessException">Cannot create an instance of an abstract class, or this member was invoked with a late-binding mechanism.</exception>
+		/// <exception cref="T:System.Runtime.InteropServices.InvalidComObjectException">The COM type was not obtained through <see cref="Overload:System.Type.GetTypeFromProgID" /> or <see cref="Overload:System.Type.GetTypeFromCLSID" />.</exception>
+		/// <exception cref="T:System.MissingMethodException">No matching constructor was found.</exception>
+		/// <exception cref="T:System.Runtime.InteropServices.COMException">
+		///   <paramref name="type" /> is a COM object but the class identifier used to obtain the type is invalid, or the identified class is not registered.</exception>
+		/// <exception cref="T:System.TypeLoadException">
+		///   <paramref name="type" /> is not a valid type.</exception>
+		// Token: 0x060004DA RID: 1242 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60004DA")]
+		[Address(RVA = "0x26BBAA0", Offset = "0x26BA8A0", VA = "0x1826BBAA0")]
+		public static object CreateInstance(Type type, BindingFlags bindingAttr, Binder binder, object[] args, CultureInfo culture, object[] activationAttributes)
+		{
+			return null;
+		}
+
+		/// <summary>Creates an instance of the specified type using the constructor that best matches the specified parameters.</summary>
+		/// <param name="type">The type of object to create.</param>
+		/// <param name="args">An array of arguments that match in number, order, and type the parameters of the constructor to invoke. If <paramref name="args" /> is an empty array or <see langword="null" />, the constructor that takes no parameters (the default constructor) is invoked.</param>
+		/// <returns>A reference to the newly created object.</returns>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="type" /> is <see langword="null" />.</exception>
+		/// <exception cref="T:System.ArgumentException">
+		///   <paramref name="type" /> is not a <see langword="RuntimeType" />.  
+		/// -or-  
+		/// <paramref name="type" /> is an open generic type (that is, the <see cref="P:System.Type.ContainsGenericParameters" /> property returns <see langword="true" />).</exception>
+		/// <exception cref="T:System.NotSupportedException">
+		///   <paramref name="type" /> cannot be a <see cref="T:System.Reflection.Emit.TypeBuilder" />.  
+		/// -or-  
+		/// Creation of <see cref="T:System.TypedReference" />, <see cref="T:System.ArgIterator" />, <see cref="T:System.Void" />, and <see cref="T:System.RuntimeArgumentHandle" /> types, or arrays of those types, is not supported.  
+		/// -or-  
+		/// The assembly that contains <paramref name="type" /> is a dynamic assembly that was created with <see cref="F:System.Reflection.Emit.AssemblyBuilderAccess.Save" />.  
+		/// -or-  
+		/// The constructor that best matches <paramref name="args" /> has <see langword="varargs" /> arguments.</exception>
+		/// <exception cref="T:System.Reflection.TargetInvocationException">The constructor being called throws an exception.</exception>
+		/// <exception cref="T:System.MethodAccessException">In the .NET for Windows Store apps or the Portable Class Library, catch the base class exception, <see cref="T:System.MemberAccessException" />, instead.  
+		///
+		///
+		///
+		///
+		///  The caller does not have permission to call this constructor.</exception>
+		/// <exception cref="T:System.MemberAccessException">Cannot create an instance of an abstract class, or this member was invoked with a late-binding mechanism.</exception>
+		/// <exception cref="T:System.Runtime.InteropServices.InvalidComObjectException">The COM type was not obtained through <see cref="Overload:System.Type.GetTypeFromProgID" /> or <see cref="Overload:System.Type.GetTypeFromCLSID" />.</exception>
+		/// <exception cref="T:System.MissingMethodException">In the .NET for Windows Store apps or the Portable Class Library, catch the base class exception, <see cref="T:System.MissingMemberException" />, instead.  
+		///
+		///
+		///
+		///
+		///  No matching public constructor was found.</exception>
+		/// <exception cref="T:System.Runtime.InteropServices.COMException">
+		///   <paramref name="type" /> is a COM object but the class identifier used to obtain the type is invalid, or the identified class is not registered.</exception>
+		/// <exception cref="T:System.TypeLoadException">
+		///   <paramref name="type" /> is not a valid type.</exception>
+		// Token: 0x060004DB RID: 1243 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60004DB")]
+		[Address(RVA = "0x26BBE70", Offset = "0x26BAC70", VA = "0x1826BBE70")]
+		public static object CreateInstance(Type type, params object[] args)
+		{
+			return null;
+		}
+
+		/// <summary>Creates an instance of the specified type using that type's default constructor.</summary>
+		/// <param name="type">The type of object to create.</param>
+		/// <returns>A reference to the newly created object.</returns>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="type" /> is <see langword="null" />.</exception>
+		/// <exception cref="T:System.ArgumentException">
+		///   <paramref name="type" /> is not a <see langword="RuntimeType" />.  
+		/// -or-  
+		/// <paramref name="type" /> is an open generic type (that is, the <see cref="P:System.Type.ContainsGenericParameters" /> property returns <see langword="true" />).</exception>
+		/// <exception cref="T:System.NotSupportedException">
+		///   <paramref name="type" /> cannot be a <see cref="T:System.Reflection.Emit.TypeBuilder" />.  
+		/// -or-  
+		/// Creation of <see cref="T:System.TypedReference" />, <see cref="T:System.ArgIterator" />, <see cref="T:System.Void" />, and <see cref="T:System.RuntimeArgumentHandle" /> types, or arrays of those types, is not supported.  
+		/// -or-  
+		/// The assembly that contains <paramref name="type" /> is a dynamic assembly that was created with <see cref="F:System.Reflection.Emit.AssemblyBuilderAccess.Save" />.</exception>
+		/// <exception cref="T:System.Reflection.TargetInvocationException">The constructor being called throws an exception.</exception>
+		/// <exception cref="T:System.MethodAccessException">In the .NET for Windows Store apps or the Portable Class Library, catch the base class exception, <see cref="T:System.MemberAccessException" />, instead.  
+		///
+		///
+		///
+		///
+		///  The caller does not have permission to call this constructor.</exception>
+		/// <exception cref="T:System.MemberAccessException">Cannot create an instance of an abstract class, or this member was invoked with a late-binding mechanism.</exception>
+		/// <exception cref="T:System.Runtime.InteropServices.InvalidComObjectException">The COM type was not obtained through <see cref="Overload:System.Type.GetTypeFromProgID" /> or <see cref="Overload:System.Type.GetTypeFromCLSID" />.</exception>
+		/// <exception cref="T:System.MissingMethodException">In the .NET for Windows Store apps or the Portable Class Library, catch the base class exception, <see cref="T:System.MissingMemberException" />, instead.  
+		///
+		///
+		///
+		///
+		///  No matching public constructor was found.</exception>
+		/// <exception cref="T:System.Runtime.InteropServices.COMException">
+		///   <paramref name="type" /> is a COM object but the class identifier used to obtain the type is invalid, or the identified class is not registered.</exception>
+		/// <exception cref="T:System.TypeLoadException">
+		///   <paramref name="type" /> is not a valid type.</exception>
+		// Token: 0x060004DC RID: 1244 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60004DC")]
+		[Address(RVA = "0x26BBE60", Offset = "0x26BAC60", VA = "0x1826BBE60")]
+		public static object CreateInstance(Type type)
+		{
+			return null;
+		}
+
+		/// <summary>Creates an instance of the specified type using that type's default constructor.</summary>
+		/// <param name="type">The type of object to create.</param>
+		/// <param name="nonPublic">
+		///   <see langword="true" /> if a public or nonpublic default constructor can match; <see langword="false" /> if only a public default constructor can match.</param>
+		/// <returns>A reference to the newly created object.</returns>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="type" /> is <see langword="null" />.</exception>
+		/// <exception cref="T:System.ArgumentException">
+		///   <paramref name="type" /> is not a <see langword="RuntimeType" />.  
+		/// -or-  
+		/// <paramref name="type" /> is an open generic type (that is, the <see cref="P:System.Type.ContainsGenericParameters" /> property returns <see langword="true" />).</exception>
+		/// <exception cref="T:System.NotSupportedException">
+		///   <paramref name="type" /> cannot be a <see cref="T:System.Reflection.Emit.TypeBuilder" />.  
+		/// -or-  
+		/// Creation of <see cref="T:System.TypedReference" />, <see cref="T:System.ArgIterator" />, <see cref="T:System.Void" />, and <see cref="T:System.RuntimeArgumentHandle" /> types, or arrays of those types, is not supported.  
+		/// -or-  
+		/// The assembly that contains <paramref name="type" /> is a dynamic assembly that was created with <see cref="F:System.Reflection.Emit.AssemblyBuilderAccess.Save" />.</exception>
+		/// <exception cref="T:System.Reflection.TargetInvocationException">The constructor being called throws an exception.</exception>
+		/// <exception cref="T:System.MethodAccessException">The caller does not have permission to call this constructor.</exception>
+		/// <exception cref="T:System.MemberAccessException">Cannot create an instance of an abstract class, or this member was invoked with a late-binding mechanism.</exception>
+		/// <exception cref="T:System.Runtime.InteropServices.InvalidComObjectException">The COM type was not obtained through <see cref="Overload:System.Type.GetTypeFromProgID" /> or <see cref="Overload:System.Type.GetTypeFromCLSID" />.</exception>
+		/// <exception cref="T:System.MissingMethodException">No matching public constructor was found.</exception>
+		/// <exception cref="T:System.Runtime.InteropServices.COMException">
+		///   <paramref name="type" /> is a COM object but the class identifier used to obtain the type is invalid, or the identified class is not registered.</exception>
+		/// <exception cref="T:System.TypeLoadException">
+		///   <paramref name="type" /> is not a valid type.</exception>
+		// Token: 0x060004DD RID: 1245 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60004DD")]
+		[Address(RVA = "0x26BBCB0", Offset = "0x26BAAB0", VA = "0x1826BBCB0")]
+		public static object CreateInstance(Type type, bool nonPublic)
+		{
+			return null;
+		}
+
+		/// <summary>Creates an instance of the type designated by the specified generic type parameter, using the parameterless constructor.</summary>
+		/// <typeparam name="T">The type to create.</typeparam>
+		/// <returns>A reference to the newly created object.</returns>
+		/// <exception cref="T:System.MissingMethodException">In the .NET for Windows Store apps or the Portable Class Library, catch the base class exception, <see cref="T:System.MissingMemberException" />, instead.  
+		///
+		///
+		///
+		///
+		///  The type that is specified for <paramref name="T" /> does not have a parameterless constructor.</exception>
+		// Token: 0x060004DE RID: 1246 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x60004DE")]
+		[Address(RVA = "0x15F56F0", Offset = "0x15F44F0", VA = "0x1815F56F0")]
+		public static T CreateInstance<T>()
+		{
+			return null;
+		}
+	}
+}

mscorlib/System/AggregateException.cs

@@ -0,0 +1,163 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Diagnostics;
+using System.Runtime.ExceptionServices;
+using System.Runtime.Serialization;
+using Cpp2IlInjected;
+
+namespace System
+{
+	/// <summary>Represents one or more errors that occur during application execution.</summary>
+	// Token: 0x02000088 RID: 136
+	[Token(Token = "0x2000088")]
+	[DebuggerDisplay("Count = {InnerExceptionCount}")]
+	[Serializable]
+	public class AggregateException : Exception
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.AggregateException" /> class with a system-supplied message that describes the error.</summary>
+		// Token: 0x0600043F RID: 1087 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x600043F")]
+		[Address(RVA = "0x26BCCD0", Offset = "0x26BBAD0", VA = "0x1826BCCD0")]
+		public AggregateException()
+		{
+		}
+
+		/// <summary>Initializes a new instance of the <see cref="T:System.AggregateException" /> class with references to the inner exceptions that are the cause of this exception.</summary>
+		/// <param name="innerExceptions">The exceptions that are the cause of the current exception.</param>
+		/// <exception cref="T:System.ArgumentNullException">The <paramref name="innerExceptions" /> argument is null.</exception>
+		/// <exception cref="T:System.ArgumentException">An element of <paramref name="innerExceptions" /> is null.</exception>
+		// Token: 0x06000440 RID: 1088 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000440")]
+		[Address(RVA = "0x26BC430", Offset = "0x26BB230", VA = "0x1826BC430")]
+		public AggregateException(IEnumerable<Exception> innerExceptions)
+		{
+		}
+
+		/// <summary>Initializes a new instance of the <see cref="T:System.AggregateException" /> class with references to the inner exceptions that are the cause of this exception.</summary>
+		/// <param name="innerExceptions">The exceptions that are the cause of the current exception.</param>
+		/// <exception cref="T:System.ArgumentNullException">The <paramref name="innerExceptions" /> argument is null.</exception>
+		/// <exception cref="T:System.ArgumentException">An element of <paramref name="innerExceptions" /> is null.</exception>
+		// Token: 0x06000441 RID: 1089 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000441")]
+		[Address(RVA = "0x26BC7E0", Offset = "0x26BB5E0", VA = "0x1826BC7E0")]
+		public AggregateException(params Exception[] innerExceptions)
+		{
+		}
+
+		/// <summary>Initializes a new instance of the <see cref="T:System.AggregateException" /> class with a specified error message and references to the inner exceptions that are the cause of this exception.</summary>
+		/// <param name="message">The error message that explains the reason for the exception.</param>
+		/// <param name="innerExceptions">The exceptions that are the cause of the current exception.</param>
+		/// <exception cref="T:System.ArgumentNullException">The <paramref name="innerExceptions" /> argument is null.</exception>
+		/// <exception cref="T:System.ArgumentException">An element of <paramref name="innerExceptions" /> is null.</exception>
+		// Token: 0x06000442 RID: 1090 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000442")]
+		[Address(RVA = "0x26BCD90", Offset = "0x26BBB90", VA = "0x1826BCD90")]
+		public AggregateException(string message, IEnumerable<Exception> innerExceptions)
+		{
+		}
+
+		/// <summary>Initializes a new instance of the <see cref="T:System.AggregateException" /> class with a specified error message and references to the inner exceptions that are the cause of this exception.</summary>
+		/// <param name="message">The error message that explains the reason for the exception.</param>
+		/// <param name="innerExceptions">The exceptions that are the cause of the current exception.</param>
+		/// <exception cref="T:System.ArgumentNullException">The <paramref name="innerExceptions" /> argument is null.</exception>
+		/// <exception cref="T:System.ArgumentException">An element of <paramref name="innerExceptions" /> is null.</exception>
+		// Token: 0x06000443 RID: 1091 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000443")]
+		[Address(RVA = "0x26BC910", Offset = "0x26BB710", VA = "0x1826BC910")]
+		public AggregateException(string message, params Exception[] innerExceptions)
+		{
+		}
+
+		// Token: 0x06000444 RID: 1092 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000444")]
+		[Address(RVA = "0x26BC500", Offset = "0x26BB300", VA = "0x1826BC500")]
+		private AggregateException(string message, IList<Exception> innerExceptions)
+		{
+		}
+
+		// Token: 0x06000445 RID: 1093 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000445")]
+		[Address(RVA = "0x26BC840", Offset = "0x26BB640", VA = "0x1826BC840")]
+		internal AggregateException(IEnumerable<ExceptionDispatchInfo> innerExceptionInfos)
+		{
+		}
+
+		// Token: 0x06000446 RID: 1094 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000446")]
+		[Address(RVA = "0x26BC730", Offset = "0x26BB530", VA = "0x1826BC730")]
+		internal AggregateException(string message, IEnumerable<ExceptionDispatchInfo> innerExceptionInfos)
+		{
+		}
+
+		// Token: 0x06000447 RID: 1095 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000447")]
+		[Address(RVA = "0x26BC920", Offset = "0x26BB720", VA = "0x1826BC920")]
+		private AggregateException(string message, IList<ExceptionDispatchInfo> innerExceptionInfos)
+		{
+		}
+
+		/// <summary>Initializes a new instance of the <see cref="T:System.AggregateException" /> class with serialized data.</summary>
+		/// <param name="info">The object that holds the serialized object data.</param>
+		/// <param name="context">The contextual information about the source or destination.</param>
+		/// <exception cref="T:System.ArgumentNullException">The <paramref name="info" /> argument is null.</exception>
+		/// <exception cref="T:System.Runtime.Serialization.SerializationException">The exception could not be deserialized correctly.</exception>
+		// Token: 0x06000448 RID: 1096 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000448")]
+		[Address(RVA = "0x26BCB50", Offset = "0x26BB950", VA = "0x1826BCB50")]
+		protected AggregateException(SerializationInfo info, StreamingContext context)
+		{
+		}
+
+		/// <summary>Initializes a new instance of the <see cref="T:System.AggregateException" /> class with serialized data.</summary>
+		/// <param name="info">The object that holds the serialized object data.</param>
+		/// <param name="context">The contextual information about the source or destination.</param>
+		/// <exception cref="T:System.ArgumentNullException">The <paramref name="info" /> argument is null.</exception>
+		// Token: 0x06000449 RID: 1097 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000449")]
+		[Address(RVA = "0x26BC070", Offset = "0x26BAE70", VA = "0x1826BC070", Slot = "10")]
+		public override void GetObjectData(SerializationInfo info, StreamingContext context)
+		{
+		}
+
+		/// <summary>Gets a read-only collection of the <see cref="T:System.Exception" /> instances that caused the current exception.</summary>
+		/// <returns>A read-only collection of the <see cref="T:System.Exception" /> instances that caused the current exception.</returns>
+		// Token: 0x17000080 RID: 128
+		// (get) Token: 0x0600044A RID: 1098 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x17000080")]
+		public ReadOnlyCollection<Exception> InnerExceptions
+		{
+			[Token(Token = "0x600044A")]
+			[Address(RVA = "0x44EC80", Offset = "0x44DA80", VA = "0x18044EC80")]
+			get
+			{
+				return null;
+			}
+		}
+
+		/// <summary>Flattens an <see cref="T:System.AggregateException" /> instances into a single, new instance.</summary>
+		/// <returns>A new, flattened <see cref="T:System.AggregateException" />.</returns>
+		// Token: 0x0600044B RID: 1099 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x600044B")]
+		[Address(RVA = "0x26BBEA0", Offset = "0x26BACA0", VA = "0x1826BBEA0")]
+		public AggregateException Flatten()
+		{
+			return null;
+		}
+
+		/// <summary>Creates and returns a string representation of the current <see cref="T:System.AggregateException" />.</summary>
+		/// <returns>A string representation of the current exception.</returns>
+		// Token: 0x0600044C RID: 1100 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x600044C")]
+		[Address(RVA = "0x26BC1B0", Offset = "0x26BAFB0", VA = "0x1826BC1B0", Slot = "3")]
+		public override string ToString()
+		{
+			return null;
+		}
+
+		// Token: 0x040001D6 RID: 470
+		[FieldOffset(Offset = "0x88")]
+		[Token(Token = "0x40001D6")]
+		private ReadOnlyCollection<Exception> m_innerExceptions;
+	}
+}

mscorlib/System/AppContextSwitches.cs

@@ -0,0 +1,22 @@
+using System;
+using Cpp2IlInjected;
+
+namespace System
+{
+	// Token: 0x02000089 RID: 137
+	[Token(Token = "0x2000089")]
+	internal static class AppContextSwitches
+	{
+		// Token: 0x040001D7 RID: 471
+		[Token(Token = "0x40001D7")]
+		public static readonly bool ThrowExceptionIfDisposedCancellationTokenSource;
+
+		// Token: 0x040001D8 RID: 472
+		[Token(Token = "0x40001D8")]
+		public static readonly bool NoAsyncCurrentCulture;
+
+		// Token: 0x040001D9 RID: 473
+		[Token(Token = "0x40001D9")]
+		public static readonly bool PreserveEventListnerObjectIdentity;
+	}
+}

mscorlib/System/AppDomain.cs

@@ -0,0 +1,586 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.Runtime.CompilerServices;
+using System.Runtime.ExceptionServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Remoting.Contexts;
+using System.Runtime.Remoting.Messaging;
+using System.Security.Policy;
+using Cpp2IlInjected;
+
+namespace System
+{
+	/// <summary>Represents an application domain, which is an isolated environment where applications execute. This class cannot be inherited.</summary>
+	// Token: 0x0200015D RID: 349
+	[Token(Token = "0x200015D")]
+	[ClassInterface(ClassInterfaceType.None)]
+	[ComVisible(true)]
+	[StructLayout(0)]
+	public sealed class AppDomain : MarshalByRefObject
+	{
+		// Token: 0x06000E79 RID: 3705 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000E79")]
+		[Address(RVA = "0x4093D0", Offset = "0x4081D0", VA = "0x1804093D0")]
+		private AppDomain()
+		{
+		}
+
+		// Token: 0x06000E7A RID: 3706 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000E7A")]
+		[Address(RVA = "0x26BE770", Offset = "0x26BD570", VA = "0x1826BE770")]
+		private AppDomainSetup getSetup()
+		{
+			return null;
+		}
+
+		/// <summary>Gets the application domain configuration information for this instance.</summary>
+		/// <returns>The application domain initialization information.</returns>
+		/// <exception cref="T:System.AppDomainUnloadedException">The operation is attempted on an unloaded application domain.</exception>
+		// Token: 0x17000155 RID: 341
+		// (get) Token: 0x06000E7B RID: 3707 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x17000155")]
+		public AppDomainSetup SetupInformation
+		{
+			[Token(Token = "0x6000E7B")]
+			[Address(RVA = "0x26BE860", Offset = "0x26BD660", VA = "0x1826BE860")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x06000E7C RID: 3708 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000E7C")]
+		[Address(RVA = "0x26BE550", Offset = "0x26BD350", VA = "0x1826BE550")]
+		private string getFriendlyName()
+		{
+			return null;
+		}
+
+		// Token: 0x06000E7D RID: 3709 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000E7D")]
+		[Address(RVA = "0x26BE740", Offset = "0x26BD540", VA = "0x1826BE740")]
+		private static AppDomain getCurDomain()
+		{
+			return null;
+		}
+
+		/// <summary>Gets the current application domain for the current <see cref="T:System.Threading.Thread" />.</summary>
+		/// <returns>The current application domain.</returns>
+		// Token: 0x17000156 RID: 342
+		// (get) Token: 0x06000E7E RID: 3710 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x17000156")]
+		public static AppDomain CurrentDomain
+		{
+			[Token(Token = "0x6000E7E")]
+			[Address(RVA = "0x26BE740", Offset = "0x26BD540", VA = "0x1826BE740")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x06000E7F RID: 3711 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000E7F")]
+		[Address(RVA = "0x26BE760", Offset = "0x26BD560", VA = "0x1826BE760")]
+		private static AppDomain getRootDomain()
+		{
+			return null;
+		}
+
+		// Token: 0x17000157 RID: 343
+		// (get) Token: 0x06000E80 RID: 3712 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x17000157")]
+		internal static AppDomain DefaultDomain
+		{
+			[Token(Token = "0x6000E80")]
+			[Address(RVA = "0x26BE780", Offset = "0x26BD580", VA = "0x1826BE780")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x06000E81 RID: 3713 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000E81")]
+		[Address(RVA = "0x26BDA70", Offset = "0x26BC870", VA = "0x1826BDA70")]
+		private Assembly[] GetAssemblies(bool refOnly)
+		{
+			return null;
+		}
+
+		/// <summary>Gets the assemblies that have been loaded into the execution context of this application domain.</summary>
+		/// <returns>An array of assemblies in this application domain.</returns>
+		/// <exception cref="T:System.AppDomainUnloadedException">The operation is attempted on an unloaded application domain.</exception>
+		// Token: 0x06000E82 RID: 3714 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000E82")]
+		[Address(RVA = "0x26BDA80", Offset = "0x26BC880", VA = "0x1826BDA80", Slot = "6")]
+		public Assembly[] GetAssemblies()
+		{
+			return null;
+		}
+
+		/// <summary>Gets the value stored in the current application domain for the specified name.</summary>
+		/// <param name="name">The name of a predefined application domain property, or the name of an application domain property you have defined.</param>
+		/// <returns>The value of the <paramref name="name" /> property, or <see langword="null" /> if the property does not exist.</returns>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="name" /> is <see langword="null" />.</exception>
+		/// <exception cref="T:System.AppDomainUnloadedException">The operation is attempted on an unloaded application domain.</exception>
+		// Token: 0x06000E83 RID: 3715 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000E83")]
+		[Address(RVA = "0x26BDAA0", Offset = "0x26BC8A0", VA = "0x1826BDAA0", Slot = "7")]
+		public object GetData(string name)
+		{
+			return null;
+		}
+
+		/// <summary>Gives the <see cref="T:System.AppDomain" /> an infinite lifetime by preventing a lease from being created.</summary>
+		/// <returns>Always <see langword="null" />.</returns>
+		/// <exception cref="T:System.AppDomainUnloadedException">The operation is attempted on an unloaded application domain.</exception>
+		// Token: 0x06000E84 RID: 3716 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000E84")]
+		[Address(RVA = "0x43E630", Offset = "0x43D430", VA = "0x18043E630", Slot = "5")]
+		public override object InitializeLifetimeService()
+		{
+			return null;
+		}
+
+		// Token: 0x06000E85 RID: 3717 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000E85")]
+		[Address(RVA = "0x26BE100", Offset = "0x26BCF00", VA = "0x1826BE100")]
+		internal Assembly LoadAssembly(string assemblyRef, Evidence securityEvidence, bool refOnly)
+		{
+			return null;
+		}
+
+		// Token: 0x06000E86 RID: 3718 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000E86")]
+		[Address(RVA = "0x26BE110", Offset = "0x26BCF10", VA = "0x1826BE110")]
+		internal Assembly LoadSatellite(AssemblyName assemblyRef, bool throwOnError)
+		{
+			return null;
+		}
+
+		/// <summary>Loads an <see cref="T:System.Reflection.Assembly" /> given its display name.</summary>
+		/// <param name="assemblyString">The display name of the assembly. See <see cref="P:System.Reflection.Assembly.FullName" />.</param>
+		/// <returns>The loaded assembly.</returns>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="assemblyString" /> is <see langword="null" /></exception>
+		/// <exception cref="T:System.IO.FileNotFoundException">
+		///   <paramref name="assemblyString" /> is not found.</exception>
+		/// <exception cref="T:System.BadImageFormatException">
+		///   <paramref name="assemblyString" /> is not a valid assembly.  
+		/// -or-  
+		/// Version 2.0 or later of the common language runtime is currently loaded and <paramref name="assemblyString" /> was compiled with a later version.</exception>
+		/// <exception cref="T:System.AppDomainUnloadedException">The operation is attempted on an unloaded application domain.</exception>
+		/// <exception cref="T:System.IO.FileLoadException">An assembly or module was loaded twice with two different evidences.</exception>
+		// Token: 0x06000E87 RID: 3719 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000E87")]
+		[Address(RVA = "0x26BE210", Offset = "0x26BD010", VA = "0x1826BE210", Slot = "8")]
+		public Assembly Load(string assemblyString)
+		{
+			return null;
+		}
+
+		// Token: 0x06000E88 RID: 3720 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000E88")]
+		[Address(RVA = "0x26BE310", Offset = "0x26BD110", VA = "0x1826BE310")]
+		internal Assembly Load(string assemblyString, Evidence assemblySecurity, bool refonly)
+		{
+			return null;
+		}
+
+		// Token: 0x06000E89 RID: 3721 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000E89")]
+		[Address(RVA = "0x26BDC80", Offset = "0x26BCA80", VA = "0x1826BDC80")]
+		private static AppDomain InternalSetDomainByID(int domain_id)
+		{
+			return null;
+		}
+
+		// Token: 0x06000E8A RID: 3722 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000E8A")]
+		[Address(RVA = "0x26BDC90", Offset = "0x26BCA90", VA = "0x1826BDC90")]
+		private static AppDomain InternalSetDomain(AppDomain context)
+		{
+			return null;
+		}
+
+		// Token: 0x06000E8B RID: 3723 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000E8B")]
+		[Address(RVA = "0x26BDC60", Offset = "0x26BCA60", VA = "0x1826BDC60")]
+		internal static void InternalPushDomainRef(AppDomain domain)
+		{
+		}
+
+		// Token: 0x06000E8C RID: 3724 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000E8C")]
+		[Address(RVA = "0x26BDC50", Offset = "0x26BCA50", VA = "0x1826BDC50")]
+		internal static void InternalPushDomainRefByID(int domain_id)
+		{
+		}
+
+		// Token: 0x06000E8D RID: 3725 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000E8D")]
+		[Address(RVA = "0x26BDC40", Offset = "0x26BCA40", VA = "0x1826BDC40")]
+		internal static void InternalPopDomainRef()
+		{
+		}
+
+		// Token: 0x06000E8E RID: 3726 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000E8E")]
+		[Address(RVA = "0x26BDC70", Offset = "0x26BCA70", VA = "0x1826BDC70")]
+		internal static Context InternalSetContext(Context context)
+		{
+			return null;
+		}
+
+		// Token: 0x06000E8F RID: 3727 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000E8F")]
+		[Address(RVA = "0x26BDC20", Offset = "0x26BCA20", VA = "0x1826BDC20")]
+		internal static Context InternalGetContext()
+		{
+			return null;
+		}
+
+		// Token: 0x06000E90 RID: 3728 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000E90")]
+		[Address(RVA = "0x26BDC20", Offset = "0x26BCA20", VA = "0x1826BDC20")]
+		internal static Context InternalGetDefaultContext()
+		{
+			return null;
+		}
+
+		// Token: 0x06000E91 RID: 3729 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000E91")]
+		[Address(RVA = "0x26BDC30", Offset = "0x26BCA30", VA = "0x1826BDC30")]
+		internal static string InternalGetProcessGuid(string newguid)
+		{
+			return null;
+		}
+
+		// Token: 0x06000E92 RID: 3730 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000E92")]
+		[Address(RVA = "0x26BDE50", Offset = "0x26BCC50", VA = "0x1826BDE50")]
+		internal static object InvokeInDomain(AppDomain domain, MethodInfo method, object obj, object[] args)
+		{
+			return null;
+		}
+
+		// Token: 0x06000E93 RID: 3731 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000E93")]
+		[Address(RVA = "0x26BDCA0", Offset = "0x26BCAA0", VA = "0x1826BDCA0")]
+		internal static object InvokeInDomainByID(int domain_id, MethodInfo method, object obj, object[] args)
+		{
+			return null;
+		}
+
+		// Token: 0x06000E94 RID: 3732 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000E94")]
+		[Address(RVA = "0x26BDB70", Offset = "0x26BC970", VA = "0x1826BDB70")]
+		internal static string GetProcessGuid()
+		{
+			return null;
+		}
+
+		// Token: 0x06000E95 RID: 3733 RVA: 0x0000C420 File Offset: 0x0000A620
+		[Token(Token = "0x6000E95")]
+		[Address(RVA = "0x1B65780", Offset = "0x1B64580", VA = "0x181B65780")]
+		private static bool InternalIsFinalizingForUnload(int domain_id)
+		{
+			return default(bool);
+		}
+
+		/// <summary>Indicates whether this application domain is unloading, and the objects it contains are being finalized by the common language runtime.</summary>
+		/// <returns>
+		///   <see langword="true" /> if this application domain is unloading and the common language runtime has started invoking finalizers; otherwise, <see langword="false" />.</returns>
+		// Token: 0x06000E96 RID: 3734 RVA: 0x0000C438 File Offset: 0x0000A638
+		[Token(Token = "0x6000E96")]
+		[Address(RVA = "0x26BE0E0", Offset = "0x26BCEE0", VA = "0x1826BE0E0")]
+		public bool IsFinalizingForUnload()
+		{
+			return default(bool);
+		}
+
+		// Token: 0x06000E97 RID: 3735 RVA: 0x0000C450 File Offset: 0x0000A650
+		[Token(Token = "0x6000E97")]
+		[Address(RVA = "0x26BE750", Offset = "0x26BD550", VA = "0x1826BE750")]
+		private int getDomainID()
+		{
+			return 0;
+		}
+
+		/// <summary>Gets the current thread identifier.</summary>
+		/// <returns>A 32-bit signed integer that is the identifier of the current thread.</returns>
+		// Token: 0x06000E98 RID: 3736 RVA: 0x0000C468 File Offset: 0x0000A668
+		[Token(Token = "0x6000E98")]
+		[Address(RVA = "0x26BDA90", Offset = "0x26BC890", VA = "0x1826BDA90")]
+		[Obsolete]
+		public static int GetCurrentThreadId()
+		{
+			return 0;
+		}
+
+		/// <summary>Obtains a string representation that includes the friendly name of the application domain and any context policies.</summary>
+		/// <returns>A string formed by concatenating the literal string "Name:", the friendly name of the application domain, and either string representations of the context policies or the string "There are no context policies."</returns>
+		/// <exception cref="T:System.AppDomainUnloadedException">The application domain represented by the current <see cref="T:System.AppDomain" /> has been unloaded.</exception>
+		// Token: 0x06000E99 RID: 3737 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000E99")]
+		[Address(RVA = "0x26BE550", Offset = "0x26BD350", VA = "0x1826BE550", Slot = "3")]
+		public override string ToString()
+		{
+			return null;
+		}
+
+		// Token: 0x06000E9A RID: 3738 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000E9A")]
+		[Address(RVA = "0x26BD320", Offset = "0x26BC120", VA = "0x1826BD320")]
+		private void DoAssemblyLoad(Assembly assembly)
+		{
+		}
+
+		// Token: 0x06000E9B RID: 3739 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000E9B")]
+		[Address(RVA = "0x26BD3F0", Offset = "0x26BC1F0", VA = "0x1826BD3F0")]
+		private Assembly DoAssemblyResolve(string name, Assembly requestingAssembly, bool refonly)
+		{
+			return null;
+		}
+
+		// Token: 0x06000E9C RID: 3740 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000E9C")]
+		[Address(RVA = "0x26BD7F0", Offset = "0x26BC5F0", VA = "0x1826BD7F0")]
+		internal Assembly DoTypeResolve(object name_or_tb)
+		{
+			return null;
+		}
+
+		// Token: 0x06000E9D RID: 3741 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000E9D")]
+		[Address(RVA = "0x26BD6C0", Offset = "0x26BC4C0", VA = "0x1826BD6C0")]
+		internal Assembly DoResourceResolve(string name, Assembly requesting)
+		{
+			return null;
+		}
+
+		// Token: 0x06000E9E RID: 3742 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000E9E")]
+		[Address(RVA = "0x26BD6A0", Offset = "0x26BC4A0", VA = "0x1826BD6A0")]
+		private void DoDomainUnload()
+		{
+		}
+
+		// Token: 0x06000E9F RID: 3743 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000E9F")]
+		[Address(RVA = "0x26BDAB0", Offset = "0x26BC8B0", VA = "0x1826BDAB0")]
+		internal byte[] GetMarshalledDomainObjRef()
+		{
+			return null;
+		}
+
+		// Token: 0x06000EA0 RID: 3744 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000EA0")]
+		[Address(RVA = "0x26BE430", Offset = "0x26BD230", VA = "0x1826BE430")]
+		internal void ProcessMessageInDomain(byte[] arrRequest, CADMethodCallMessage cadMsg, out byte[] arrResponse, out CADMethodReturnMessage cadMrm)
+		{
+		}
+
+		/// <summary>Occurs when an <see cref="T:System.AppDomain" /> is about to be unloaded.</summary>
+		// Token: 0x14000003 RID: 3
+		// (add) Token: 0x06000EA1 RID: 3745 RVA: 0x00002050 File Offset: 0x00000250
+		// (remove) Token: 0x06000EA2 RID: 3746 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x14000003")]
+		public event EventHandler DomainUnload
+		{
+			[Token(Token = "0x6000EA1")]
+			[Address(RVA = "0x26BE560", Offset = "0x26BD360", VA = "0x1826BE560", Slot = "9")]
+			[CompilerGenerated]
+			add
+			{
+			}
+			[Token(Token = "0x6000EA2")]
+			[Address(RVA = "0x26BE990", Offset = "0x26BD790", VA = "0x1826BE990", Slot = "10")]
+			[CompilerGenerated]
+			remove
+			{
+			}
+		}
+
+		/// <summary>Occurs when the default application domain's parent process exits.</summary>
+		// Token: 0x14000004 RID: 4
+		// (add) Token: 0x06000EA3 RID: 3747 RVA: 0x00002050 File Offset: 0x00000250
+		// (remove) Token: 0x06000EA4 RID: 3748 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x14000004")]
+		public event EventHandler ProcessExit
+		{
+			[Token(Token = "0x6000EA3")]
+			[Address(RVA = "0x26BE600", Offset = "0x26BD400", VA = "0x1826BE600", Slot = "11")]
+			[CompilerGenerated]
+			add
+			{
+			}
+			[Token(Token = "0x6000EA4")]
+			[Address(RVA = "0x26BEA30", Offset = "0x26BD830", VA = "0x1826BEA30", Slot = "12")]
+			[CompilerGenerated]
+			remove
+			{
+			}
+		}
+
+		/// <summary>Occurs when an exception is not caught.</summary>
+		// Token: 0x14000005 RID: 5
+		// (add) Token: 0x06000EA5 RID: 3749 RVA: 0x00002050 File Offset: 0x00000250
+		// (remove) Token: 0x06000EA6 RID: 3750 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x14000005")]
+		public event UnhandledExceptionEventHandler UnhandledException
+		{
+			[Token(Token = "0x6000EA5")]
+			[Address(RVA = "0x26BE6A0", Offset = "0x26BD4A0", VA = "0x1826BE6A0", Slot = "13")]
+			[CompilerGenerated]
+			add
+			{
+			}
+			[Token(Token = "0x6000EA6")]
+			[Address(RVA = "0x26BEAD0", Offset = "0x26BD8D0", VA = "0x1826BEAD0", Slot = "14")]
+			[CompilerGenerated]
+			remove
+			{
+			}
+		}
+
+		/// <summary>Returns a value that indicates whether the application domain is the default application domain for the process.</summary>
+		/// <returns>
+		///   <see langword="true" /> if the current <see cref="T:System.AppDomain" /> object represents the default application domain for the process; otherwise, <see langword="false" />.</returns>
+		// Token: 0x06000EA7 RID: 3751 RVA: 0x0000C480 File Offset: 0x0000A680
+		[Token(Token = "0x6000EA7")]
+		[Address(RVA = "0x26BE000", Offset = "0x26BCE00", VA = "0x1826BE000")]
+		public bool IsDefaultAppDomain()
+		{
+			return default(bool);
+		}
+
+		/// <summary>Defines a dynamic assembly with the specified name and access mode.</summary>
+		/// <param name="name">The unique identity of the dynamic assembly.</param>
+		/// <param name="access">The access mode for the dynamic assembly.</param>
+		/// <returns>A dynamic assembly with the specified name and access mode.</returns>
+		/// <exception cref="T:System.ArgumentNullException">
+		///   <paramref name="name" /> is <see langword="null" />.</exception>
+		/// <exception cref="T:System.ArgumentException">The <see langword="Name" /> property of <paramref name="name" /> is <see langword="null" />.  
+		///  -or-  
+		///  The <see langword="Name" /> property of <paramref name="name" /> begins with white space, or contains a forward or backward slash.</exception>
+		/// <exception cref="T:System.AppDomainUnloadedException">The operation is attempted on an unloaded application domain.</exception>
+		// Token: 0x06000EA8 RID: 3752 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000EA8")]
+		[Address(RVA = "0x26BD2F0", Offset = "0x26BC0F0", VA = "0x1826BD2F0", Slot = "15")]
+		public AssemblyBuilder DefineDynamicAssembly(AssemblyName name, AssemblyBuilderAccess access)
+		{
+			return null;
+		}
+
+		// Token: 0x04000596 RID: 1430
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x18")]
+		[Token(Token = "0x4000596")]
+		private IntPtr _mono_app_domain;
+
+		// Token: 0x04000597 RID: 1431
+		[Token(Token = "0x4000597")]
+		private static string _process_guid;
+
+		// Token: 0x04000598 RID: 1432
+		[Token(Token = "0x4000598")]
+		[ThreadStatic]
+		private static Dictionary<string, object> type_resolve_in_progress;
+
+		// Token: 0x04000599 RID: 1433
+		[Token(Token = "0x4000599")]
+		[ThreadStatic]
+		private static Dictionary<string, object> assembly_resolve_in_progress;
+
+		// Token: 0x0400059A RID: 1434
+		[Token(Token = "0x400059A")]
+		[ThreadStatic]
+		private static Dictionary<string, object> assembly_resolve_in_progress_refonly;
+
+		// Token: 0x0400059B RID: 1435
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x20")]
+		[Token(Token = "0x400059B")]
+		private object _evidence;
+
+		// Token: 0x0400059C RID: 1436
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x28")]
+		[Token(Token = "0x400059C")]
+		private object _granted;
+
+		// Token: 0x0400059D RID: 1437
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x30")]
+		[Token(Token = "0x400059D")]
+		private int _principalPolicy;
+
+		// Token: 0x0400059E RID: 1438
+		[Token(Token = "0x400059E")]
+		[ThreadStatic]
+		private static object _principal;
+
+		// Token: 0x0400059F RID: 1439
+		[Token(Token = "0x400059F")]
+		private static AppDomain default_domain;
+
+		// Token: 0x040005A0 RID: 1440
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x38")]
+		[Token(Token = "0x40005A0")]
+		[CompilerGenerated]
+		private AssemblyLoadEventHandler AssemblyLoad;
+
+		// Token: 0x040005A1 RID: 1441
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x40")]
+		[Token(Token = "0x40005A1")]
+		[CompilerGenerated]
+		private ResolveEventHandler AssemblyResolve;
+
+		// Token: 0x040005A4 RID: 1444
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x58")]
+		[Token(Token = "0x40005A4")]
+		[CompilerGenerated]
+		private ResolveEventHandler ResourceResolve;
+
+		// Token: 0x040005A5 RID: 1445
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x60")]
+		[Token(Token = "0x40005A5")]
+		[CompilerGenerated]
+		private ResolveEventHandler TypeResolve;
+
+		// Token: 0x040005A7 RID: 1447
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x70")]
+		[Token(Token = "0x40005A7")]
+		[CompilerGenerated]
+		private EventHandler<FirstChanceExceptionEventArgs> FirstChanceException;
+
+		// Token: 0x040005A8 RID: 1448
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x78")]
+		[Token(Token = "0x40005A8")]
+		private object _domain_manager;
+
+		// Token: 0x040005A9 RID: 1449
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x80")]
+		[Token(Token = "0x40005A9")]
+		[CompilerGenerated]
+		private ResolveEventHandler ReflectionOnlyAssemblyResolve;
+
+		// Token: 0x040005AA RID: 1450
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x88")]
+		[Token(Token = "0x40005AA")]
+		private object _activation;
+
+		// Token: 0x040005AB RID: 1451
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x90")]
+		[Token(Token = "0x40005AB")]
+		private object _applicationIdentity;
+
+		// Token: 0x040005AC RID: 1452
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x98")]
+		[Token(Token = "0x40005AC")]
+		private List<string> compatibility_switch;
+	}
+}

mscorlib/System/AppDomainSetup.cs

@@ -0,0 +1,179 @@
+using System;
+using System.Runtime.InteropServices;
+using Cpp2IlInjected;
+
+namespace System
+{
+	/// <summary>Represents assembly binding information that can be added to an instance of <see cref="T:System.AppDomain" />.</summary>
+	// Token: 0x02000166 RID: 358
+	[Token(Token = "0x2000166")]
+	[ClassInterface(ClassInterfaceType.None)]
+	[ComVisible(true)]
+	[Serializable]
+	[StructLayout(0)]
+	public sealed class AppDomainSetup
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.AppDomainSetup" /> class.</summary>
+		// Token: 0x06000EDE RID: 3806 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000EDE")]
+		[Address(RVA = "0x3F5100", Offset = "0x3F3F00", VA = "0x1803F5100")]
+		public AppDomainSetup()
+		{
+		}
+
+		// Token: 0x06000EDF RID: 3807 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x6000EDF")]
+		[Address(RVA = "0x26BD190", Offset = "0x26BBF90", VA = "0x1826BD190")]
+		internal AppDomainSetup(AppDomainSetup setup)
+		{
+		}
+
+		// Token: 0x06000EE0 RID: 3808 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x6000EE0")]
+		[Address(RVA = "0x26BCE40", Offset = "0x26BBC40", VA = "0x1826BCE40")]
+		private static string GetAppBase(string appBase)
+		{
+			return null;
+		}
+
+		/// <summary>Gets or sets the name of the directory containing the application.</summary>
+		/// <returns>The name of the application base directory.</returns>
+		// Token: 0x17000166 RID: 358
+		// (get) Token: 0x06000EE1 RID: 3809 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x17000166")]
+		public string ApplicationBase
+		{
+			[Token(Token = "0x6000EE1")]
+			[Address(RVA = "0x26BD280", Offset = "0x26BC080", VA = "0x1826BD280", Slot = "4")]
+			get
+			{
+				return null;
+			}
+		}
+
+		/// <summary>Gets or sets the location of the license file associated with this domain.</summary>
+		/// <returns>The location and name of the license file.</returns>
+		// Token: 0x17000167 RID: 359
+		// (get) Token: 0x06000EE2 RID: 3810 RVA: 0x00002082 File Offset: 0x00000282
+		[Token(Token = "0x17000167")]
+		public string LicenseFile
+		{
+			[Token(Token = "0x6000EE2")]
+			[Address(RVA = "0x3F63D0", Offset = "0x3F51D0", VA = "0x1803F63D0", Slot = "5")]
+			get
+			{
+				return null;
+			}
+		}
+
+		// Token: 0x040005E8 RID: 1512
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x10")]
+		[Token(Token = "0x40005E8")]
+		private string application_base;
+
+		// Token: 0x040005E9 RID: 1513
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x18")]
+		[Token(Token = "0x40005E9")]
+		private string application_name;
+
+		// Token: 0x040005EA RID: 1514
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x20")]
+		[Token(Token = "0x40005EA")]
+		private string cache_path;
+
+		// Token: 0x040005EB RID: 1515
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x28")]
+		[Token(Token = "0x40005EB")]
+		private string configuration_file;
+
+		// Token: 0x040005EC RID: 1516
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x30")]
+		[Token(Token = "0x40005EC")]
+		private string dynamic_base;
+
+		// Token: 0x040005ED RID: 1517
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x38")]
+		[Token(Token = "0x40005ED")]
+		private string license_file;
+
+		// Token: 0x040005EE RID: 1518
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x40")]
+		[Token(Token = "0x40005EE")]
+		private string private_bin_path;
+
+		// Token: 0x040005EF RID: 1519
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x48")]
+		[Token(Token = "0x40005EF")]
+		private string private_bin_path_probe;
+
+		// Token: 0x040005F0 RID: 1520
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x50")]
+		[Token(Token = "0x40005F0")]
+		private string shadow_copy_directories;
+
+		// Token: 0x040005F1 RID: 1521
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x58")]
+		[Token(Token = "0x40005F1")]
+		private string shadow_copy_files;
+
+		// Token: 0x040005F2 RID: 1522
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x60")]
+		[Token(Token = "0x40005F2")]
+		private bool publisher_policy;
+
+		// Token: 0x040005F3 RID: 1523
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x61")]
+		[Token(Token = "0x40005F3")]
+		private bool path_changed;
+
+		// Token: 0x040005F4 RID: 1524
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x64")]
+		[Token(Token = "0x40005F4")]
+		private int loader_optimization;
+
+		// Token: 0x040005F5 RID: 1525
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x68")]
+		[Token(Token = "0x40005F5")]
+		private bool disallow_binding_redirects;
+
+		// Token: 0x040005F6 RID: 1526
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x69")]
+		[Token(Token = "0x40005F6")]
+		private bool disallow_code_downloads;
+
+		// Token: 0x040005F7 RID: 1527
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x70")]
+		[Token(Token = "0x40005F7")]
+		private object _activationArguments;
+
+		// Token: 0x040005F8 RID: 1528
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x78")]
+		[Token(Token = "0x40005F8")]
+		private object domain_initializer;
+
+		// Token: 0x040005F9 RID: 1529
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x80")]
+		[Token(Token = "0x40005F9")]
+		private object application_trust;
+
+		// Token: 0x040005FA RID: 1530
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x88")]
+		[Token(Token = "0x40005FA")]
+		private string[] domain_initializer_args;
+
+		// Token: 0x040005FB RID: 1531
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x90")]
+		[Token(Token = "0x40005FB")]
+		private bool disallow_appbase_probe;
+
+		// Token: 0x040005FC RID: 1532
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0x98")]
+		[Token(Token = "0x40005FC")]
+		private byte[] configuration_bytes;
+
+		// Token: 0x040005FD RID: 1533
+		[global::Cpp2IlInjected.FieldOffset(Offset = "0xA0")]
+		[Token(Token = "0x40005FD")]
+		private byte[] serialized_non_primitives;
+	}
+}

mscorlib/System/AppDomainUnloadedException.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Runtime.Serialization;
+using Cpp2IlInjected;
+
+namespace System
+{
+	/// <summary>The exception that is thrown when an attempt is made to access an unloaded application domain.</summary>
+	// Token: 0x020000AD RID: 173
+	[Token(Token = "0x20000AD")]
+	[ComVisible(true)]
+	[Serializable]
+	public class AppDomainUnloadedException : SystemException
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.AppDomainUnloadedException" /> class.</summary>
+		// Token: 0x060004DF RID: 1247 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60004DF")]
+		[Address(RVA = "0x26BD290", Offset = "0x26BC090", VA = "0x1826BD290")]
+		public AppDomainUnloadedException()
+		{
+		}
+
+		/// <summary>Initializes a new instance of the <see cref="T:System.AppDomainUnloadedException" /> class with serialized data.</summary>
+		/// <param name="info">The object that holds the serialized object data.</param>
+		/// <param name="context">The contextual information about the source or destination.</param>
+		// Token: 0x060004E0 RID: 1248 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60004E0")]
+		[Address(RVA = "0x3F60E0", Offset = "0x3F4EE0", VA = "0x1803F60E0")]
+		protected AppDomainUnloadedException(SerializationInfo info, StreamingContext context)
+		{
+		}
+	}
+}

mscorlib/System/ApplicationException.cs

@@ -0,0 +1,52 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Runtime.Serialization;
+using Cpp2IlInjected;
+
+namespace System
+{
+	/// <summary>Serves as the base class for application-defined exceptions.</summary>
+	// Token: 0x020000AE RID: 174
+	[Token(Token = "0x20000AE")]
+	[ComVisible(true)]
+	[Serializable]
+	public class ApplicationException : Exception
+	{
+		/// <summary>Initializes a new instance of the <see cref="T:System.ApplicationException" /> class.</summary>
+		// Token: 0x060004E1 RID: 1249 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60004E1")]
+		[Address(RVA = "0x26BEC00", Offset = "0x26BDA00", VA = "0x1826BEC00")]
+		public ApplicationException()
+		{
+		}
+
+		/// <summary>Initializes a new instance of the <see cref="T:System.ApplicationException" /> class with a specified error message.</summary>
+		/// <param name="message">A message that describes the error.</param>
+		// Token: 0x060004E2 RID: 1250 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60004E2")]
+		[Address(RVA = "0x26BEC80", Offset = "0x26BDA80", VA = "0x1826BEC80")]
+		public ApplicationException(string message)
+		{
+		}
+
+		/// <summary>Initializes a new instance of the <see cref="T:System.ApplicationException" /> 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="innerException">The exception that is the cause of the current exception. If the <paramref name="innerException" /> parameter is not a null reference, the current exception is raised in a <see langword="catch" /> block that handles the inner exception.</param>
+		// Token: 0x060004E3 RID: 1251 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60004E3")]
+		[Address(RVA = "0x26BEB70", Offset = "0x26BD970", VA = "0x1826BEB70")]
+		public ApplicationException(string message, Exception innerException)
+		{
+		}
+
+		/// <summary>Initializes a new instance of the <see cref="T:System.ApplicationException" /> class with serialized data.</summary>
+		/// <param name="info">The object that holds the serialized object data.</param>
+		/// <param name="context">The contextual information about the source or destination.</param>
+		// Token: 0x060004E4 RID: 1252 RVA: 0x00002050 File Offset: 0x00000250
+		[Token(Token = "0x60004E4")]
+		[Address(RVA = "0x26BED00", Offset = "0x26BDB00", VA = "0x1826BED00")]
+		protected ApplicationException(SerializationInfo info, StreamingContext context)
+		{
+		}
+	}
+}