# System

``` diff
+namespace System {
+    public class AccessViolationException : SystemException {
+        public AccessViolationException();
+        public AccessViolationException(string message);
+        public AccessViolationException(string message, Exception innerException);
+    }
+    public delegate void Action();
+    public delegate void Action<in T>(T obj);
+    public delegate void Action<in T1, in T2>(T1 arg1, T2 arg2);
+    public delegate void Action<in T1, in T2, in T3>(T1 arg1, T2 arg2, T3 arg3);
+    public delegate void Action<in T1, in T2, in T3, in T4>(T1 arg1, T2 arg2, T3 arg3, T4 arg4);
+    public delegate void Action<in T1, in T2, in T3, in T4, in T5>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5);
+    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);
+    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);
+    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);
+    public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9);
+    public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10);
+    public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11);
+    public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, in T12>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12);
+    public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, in T12, in T13>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13);
+    public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, in T12, in T13, in T14>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14);
+    public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, in T12, in T13, in T14, in T15>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15);
+    public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, in T12, in T13, in T14, in T15, in T16>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16);
+    public static class Activator {
+        public static object CreateInstance(Type type);
+        public static object CreateInstance(Type type, bool nonPublic);
+        public static object CreateInstance(Type type, params object[] args);
+        public static T CreateInstance<T>();
+    }
+    public class AggregateException : Exception {
+        public AggregateException();
+        public AggregateException(IEnumerable<Exception> innerExceptions);
+        public AggregateException(params Exception[] innerExceptions);
+        public AggregateException(string message);
+        public AggregateException(string message, IEnumerable<Exception> innerExceptions);
+        public AggregateException(string message, Exception innerException);
+        public AggregateException(string message, params Exception[] innerExceptions);
+        public ReadOnlyCollection<Exception> InnerExceptions { get; }
+        public override string Message { get; }
+        public AggregateException Flatten();
+        public override Exception GetBaseException();
+        public void Handle(Func<Exception, bool> predicate);
+        public override string ToString();
+    }
+    public static class AppContext {
+        public static string BaseDirectory { get; }
+        public static string TargetFrameworkName { get; }
+        public static object GetData(string name);
+        public static void SetSwitch(string switchName, bool isEnabled);
+        public static bool TryGetSwitch(string switchName, out bool isEnabled);
+    }
+    public sealed class AppDomain : _AppDomain {
+        public string BaseDirectory { get; }
+        public static AppDomain CurrentDomain { get; }
+        public bool IsFullyTrusted { get; }
+        public object GetData(string name);
+        public override string ToString();
+    }
+    public class AppDomainManager {
+        public AppDomainManager();
+        public virtual bool CheckSecuritySettings(SecurityState state);
+        public virtual void InitializeNewDomain(AppDomainSetup appDomainInfo);
+    }
+    public sealed class AppDomainSetup
+    public class AppDomainUnloadedException : SystemException {
+        public AppDomainUnloadedException();
+        public AppDomainUnloadedException(string message);
+        public AppDomainUnloadedException(string message, Exception innerException);
+    }
+    public class ApplicationException : Exception {
+        public ApplicationException();
+        public ApplicationException(string message);
+        public ApplicationException(string message, Exception innerException);
+    }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct ArgIterator {
+        public override bool Equals(object o);
+        public override int GetHashCode();
+    }
+    public class ArgumentException : Exception {
+        public ArgumentException();
+        public ArgumentException(string message);
+        public ArgumentException(string message, Exception innerException);
+        public ArgumentException(string message, string paramName);
+        public ArgumentException(string message, string paramName, Exception innerException);
+        public override string Message { get; }
+        public virtual string ParamName { get; }
+    }
+    public class ArgumentNullException : ArgumentException {
+        public ArgumentNullException();
+        public ArgumentNullException(string paramName);
+        public ArgumentNullException(string message, Exception innerException);
+        public ArgumentNullException(string paramName, string message);
+    }
+    public class ArgumentOutOfRangeException : ArgumentException {
+        public ArgumentOutOfRangeException();
+        public ArgumentOutOfRangeException(string paramName);
+        public ArgumentOutOfRangeException(string message, Exception innerException);
+        public ArgumentOutOfRangeException(string paramName, object actualValue, string message);
+        public ArgumentOutOfRangeException(string paramName, string message);
+        public virtual object ActualValue { get; }
+        public override string Message { get; }
+    }
+    public class ArithmeticException : Exception {
+        public ArithmeticException();
+        public ArithmeticException(string message);
+        public ArithmeticException(string message, Exception innerException);
+    }
+    public abstract class Array : ICollection, IEnumerable, IList, IStructuralComparable, IStructuralEquatable {
+        public bool IsFixedSize { get; }
+        public bool IsReadOnly { get; }
+        public bool IsSynchronized { get; }
+        public int Length { get; }
+        public int Rank { get; }
+        public object SyncRoot { get; }
+        int System.Collections.ICollection.Count { get; }
+        bool System.Collections.ICollection.IsSynchronized { get; }
+        object System.Collections.ICollection.SyncRoot { get; }
+        bool System.Collections.IList.IsFixedSize { get; }
+        bool System.Collections.IList.IsReadOnly { get; }
+        object System.Collections.IList.this[int index] { get; set; }
+        public static ReadOnlyCollection<T> AsReadOnly<T>(T[] array);
+        public static int BinarySearch(Array array, int index, int length, object value);
+        public static int BinarySearch(Array array, int index, int length, object value, IComparer comparer);
+        public static int BinarySearch(Array array, object value);
+        public static int BinarySearch(Array array, object value, IComparer comparer);
+        public static int BinarySearch<T>(T[] array, int index, int length, T value);
+        public static int BinarySearch<T>(T[] array, int index, int length, T value, IComparer<T> comparer);
+        public static int BinarySearch<T>(T[] array, T value);
+        public static int BinarySearch<T>(T[] array, T value, IComparer<T> comparer);
+        public static void Clear(Array array, int index, int length);
+        public object Clone();
+        public static void ConstrainedCopy(Array sourceArray, int sourceIndex, Array destinationArray, int destinationIndex, int length);
+        public static void Copy(Array sourceArray, Array destinationArray, int length);
+        public static void Copy(Array sourceArray, int sourceIndex, Array destinationArray, int destinationIndex, int length);
+        public void CopyTo(Array array, int index);
+        public static Array CreateInstance(Type elementType, int length);
+        public static Array CreateInstance(Type elementType, params int[] lengths);
+        public static Array CreateInstance(Type elementType, int[] lengths, int[] lowerBounds);
+        public static T[] Empty<T>();
+        public static bool Exists<T>(T[] array, Predicate<T> match);
+        public static T Find<T>(T[] array, Predicate<T> match);
+        public static T[] FindAll<T>(T[] array, Predicate<T> match);
+        public static int FindIndex<T>(T[] array, int startIndex, int count, Predicate<T> match);
+        public static int FindIndex<T>(T[] array, int startIndex, Predicate<T> match);
+        public static int FindIndex<T>(T[] array, Predicate<T> match);
+        public static T FindLast<T>(T[] array, Predicate<T> match);
+        public static int FindLastIndex<T>(T[] array, int startIndex, int count, Predicate<T> match);
+        public static int FindLastIndex<T>(T[] array, int startIndex, Predicate<T> match);
+        public static int FindLastIndex<T>(T[] array, Predicate<T> match);
+        public static void ForEach<T>(T[] array, Action<T> action);
+        public IEnumerator GetEnumerator();
+        public int GetLength(int dimension);
+        public int GetLowerBound(int dimension);
+        public int GetUpperBound(int dimension);
+        public object GetValue(int index);
+        public object GetValue(params int[] indices);
+        public static int IndexOf(Array array, object value);
+        public static int IndexOf(Array array, object value, int startIndex);
+        public static int IndexOf(Array array, object value, int startIndex, int count);
+        public static int IndexOf<T>(T[] array, T value);
+        public static int IndexOf<T>(T[] array, T value, int startIndex);
+        public static int IndexOf<T>(T[] array, T value, int startIndex, int count);
+        public void Initialize();
+        public static int LastIndexOf(Array array, object value);
+        public static int LastIndexOf(Array array, object value, int startIndex);
+        public static int LastIndexOf(Array array, object value, int startIndex, int count);
+        public static int LastIndexOf<T>(T[] array, T value);
+        public static int LastIndexOf<T>(T[] array, T value, int startIndex);
+        public static int LastIndexOf<T>(T[] array, T value, int startIndex, int count);
+        public static void Resize<T>(ref T[] array, int newSize);
+        public static void Reverse(Array array);
+        public static void Reverse(Array array, int index, int length);
+        public void SetValue(object value, int index);
+        public void SetValue(object value, params int[] indices);
+        public static void Sort(Array array);
+        public static void Sort(Array keys, Array items);
+        public static void Sort(Array keys, Array items, IComparer comparer);
+        public static void Sort(Array keys, Array items, int index, int length);
+        public static void Sort(Array keys, Array items, int index, int length, IComparer comparer);
+        public static void Sort(Array array, IComparer comparer);
+        public static void Sort(Array array, int index, int length);
+        public static void Sort(Array array, int index, int length, IComparer comparer);
+        public static void Sort<T>(T[] array);
+        public static void Sort<T>(T[] array, IComparer<T> comparer);
+        public static void Sort<T>(T[] array, Comparison<T> comparison);
+        public static void Sort<T>(T[] array, int index, int length);
+        public static void Sort<T>(T[] array, int index, int length, IComparer<T> comparer);
+        public static void Sort<TKey, TValue>(TKey[] keys, TValue[] items);
+        public static void Sort<TKey, TValue>(TKey[] keys, TValue[] items, IComparer<TKey> comparer);
+        public static void Sort<TKey, TValue>(TKey[] keys, TValue[] items, int index, int length);
+        public static void Sort<TKey, TValue>(TKey[] keys, TValue[] items, int index, int length, IComparer<TKey> comparer);
+        int System.Collections.IList.Add(object value);
+        void System.Collections.IList.Clear();
+        bool System.Collections.IList.Contains(object value);
+        int System.Collections.IList.IndexOf(object value);
+        void System.Collections.IList.Insert(int index, object value);
+        void System.Collections.IList.Remove(object value);
+        void System.Collections.IList.RemoveAt(int index);
+        int System.Collections.IStructuralComparable.CompareTo(object other, IComparer comparer);
+        bool System.Collections.IStructuralEquatable.Equals(object other, IEqualityComparer comparer);
+        int System.Collections.IStructuralEquatable.GetHashCode(IEqualityComparer comparer);
+        public static bool TrueForAll<T>(T[] array, Predicate<T> match);
+    }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct ArraySegment<T> : ICollection<T>, IEnumerable, IEnumerable<T>, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T> {
+        public ArraySegment(T[] array);
+        public ArraySegment(T[] array, int offset, int count);
+        public T[] Array { get; }
+        public int Count { get; }
+        public int Offset { get; }
+        bool System.Collections.Generic.ICollection<T>.IsReadOnly { get; }
+        T System.Collections.Generic.IList<T>.this[int index] { get; set; }
+        T System.Collections.Generic.IReadOnlyList<T>.this[int index] { get; }
+        public bool Equals(ArraySegment<T> obj);
+        public override bool Equals(object obj);
+        public override int GetHashCode();
+        public static bool operator ==(ArraySegment<T> a, ArraySegment<T> b);
+        public static bool operator !=(ArraySegment<T> a, ArraySegment<T> b);
+        void System.Collections.Generic.ICollection<T>.Add(T item);
+        void System.Collections.Generic.ICollection<T>.Clear();
+        bool System.Collections.Generic.ICollection<T>.Contains(T item);
+        void System.Collections.Generic.ICollection<T>.CopyTo(T[] array, int arrayIndex);
+        bool System.Collections.Generic.ICollection<T>.Remove(T item);
+        IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator();
+        int System.Collections.Generic.IList<T>.IndexOf(T item);
+        void System.Collections.Generic.IList<T>.Insert(int index, T item);
+        void System.Collections.Generic.IList<T>.RemoveAt(int index);
+        IEnumerator System.Collections.IEnumerable.GetEnumerator();
+    }
+    public class ArrayTypeMismatchException : Exception {
+        public ArrayTypeMismatchException();
+        public ArrayTypeMismatchException(string message);
+        public ArrayTypeMismatchException(string message, Exception innerException);
+    }
+    public delegate void AsyncCallback(IAsyncResult ar);
+    public abstract class Attribute {
+        protected Attribute();
+        public override bool Equals(object obj);
+        public static Attribute GetCustomAttribute(Assembly element, Type attributeType);
+        public static Attribute GetCustomAttribute(Assembly element, Type attributeType, bool inherit);
+        public static Attribute GetCustomAttribute(MemberInfo element, Type attributeType);
+        public static Attribute GetCustomAttribute(MemberInfo element, Type attributeType, bool inherit);
+        public static Attribute GetCustomAttribute(Module element, Type attributeType);
+        public static Attribute GetCustomAttribute(Module element, Type attributeType, bool inherit);
+        public static Attribute GetCustomAttribute(ParameterInfo element, Type attributeType);
+        public static Attribute GetCustomAttribute(ParameterInfo element, Type attributeType, bool inherit);
+        public static Attribute[] GetCustomAttributes(Assembly element);
+        public static Attribute[] GetCustomAttributes(Assembly element, bool inherit);
+        public static Attribute[] GetCustomAttributes(Assembly element, Type attributeType);
+        public static Attribute[] GetCustomAttributes(Assembly element, Type attributeType, bool inherit);
+        public static Attribute[] GetCustomAttributes(MemberInfo element);
+        public static Attribute[] GetCustomAttributes(MemberInfo element, bool inherit);
+        public static Attribute[] GetCustomAttributes(MemberInfo element, Type type);
+        public static Attribute[] GetCustomAttributes(MemberInfo element, Type type, bool inherit);
+        public static Attribute[] GetCustomAttributes(Module element);
+        public static Attribute[] GetCustomAttributes(Module element, bool inherit);
+        public static Attribute[] GetCustomAttributes(Module element, Type attributeType);
+        public static Attribute[] GetCustomAttributes(Module element, Type attributeType, bool inherit);
+        public static Attribute[] GetCustomAttributes(ParameterInfo element);
+        public static Attribute[] GetCustomAttributes(ParameterInfo element, bool inherit);
+        public static Attribute[] GetCustomAttributes(ParameterInfo element, Type attributeType);
+        public static Attribute[] GetCustomAttributes(ParameterInfo element, Type attributeType, bool inherit);
+        public override int GetHashCode();
+        public static bool IsDefined(Assembly element, Type attributeType);
+        public static bool IsDefined(Assembly element, Type attributeType, bool inherit);
+        public static bool IsDefined(MemberInfo element, Type attributeType);
+        public static bool IsDefined(MemberInfo element, Type attributeType, bool inherit);
+        public static bool IsDefined(Module element, Type attributeType);
+        public static bool IsDefined(Module element, Type attributeType, bool inherit);
+        public static bool IsDefined(ParameterInfo element, Type attributeType);
+        public static bool IsDefined(ParameterInfo element, Type attributeType, bool inherit);
+        public virtual bool Match(object obj);
+    }
+    public enum AttributeTargets {
+        All = 32767,
+        Assembly = 1,
+        Class = 4,
+        Constructor = 32,
+        Delegate = 4096,
+        Enum = 16,
+        Event = 512,
+        Field = 256,
+        GenericParameter = 16384,
+        Interface = 1024,
+        Method = 64,
+        Module = 2,
+        Parameter = 2048,
+        Property = 128,
+        ReturnValue = 8192,
+        Struct = 8,
+    }
+    public sealed class AttributeUsageAttribute : Attribute {
+        public AttributeUsageAttribute(AttributeTargets validOn);
+        public bool AllowMultiple { get; set; }
+        public bool Inherited { get; set; }
+        public AttributeTargets ValidOn { get; }
+    }
+    public class BadImageFormatException : Exception {
+        public BadImageFormatException();
+        public BadImageFormatException(string message);
+        public BadImageFormatException(string message, Exception inner);
+        public BadImageFormatException(string message, string fileName);
+        public BadImageFormatException(string message, string fileName, Exception inner);
+        public string FileName { get; }
+        public override string Message { get; }
+        public override string ToString();
+    }
+    public static class BitConverter {
+        public static readonly bool IsLittleEndian;
+        public static long DoubleToInt64Bits(double value);
+        public static byte[] GetBytes(bool value);
+        public static byte[] GetBytes(char value);
+        public static byte[] GetBytes(double value);
+        public static byte[] GetBytes(short value);
+        public static byte[] GetBytes(int value);
+        public static byte[] GetBytes(long value);
+        public static byte[] GetBytes(float value);
+        public static byte[] GetBytes(ushort value);
+        public static byte[] GetBytes(uint value);
+        public static byte[] GetBytes(ulong value);
+        public static double Int64BitsToDouble(long value);
+        public static bool ToBoolean(byte[] value, int startIndex);
+        public static char ToChar(byte[] value, int startIndex);
+        public static double ToDouble(byte[] value, int startIndex);
+        public static short ToInt16(byte[] value, int startIndex);
+        public static int ToInt32(byte[] value, int startIndex);
+        public static long ToInt64(byte[] value, int startIndex);
+        public static float ToSingle(byte[] value, int startIndex);
+        public static string ToString(byte[] value);
+        public static string ToString(byte[] value, int startIndex);
+        public static string ToString(byte[] value, int startIndex, int length);
+        public static ushort ToUInt16(byte[] value, int startIndex);
+        public static uint ToUInt32(byte[] value, int startIndex);
+        public static ulong ToUInt64(byte[] value, int startIndex);
+    }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct Boolean : IComparable, IComparable<bool>, IConvertible, IEquatable<bool> {
+        public static readonly string FalseString;
+        public static readonly string TrueString;
+        public int CompareTo(bool value);
+        public int CompareTo(object obj);
+        public bool Equals(bool obj);
+        public override bool Equals(object obj);
+        public override int GetHashCode();
+        public TypeCode GetTypeCode();
+        public static bool Parse(string value);
+        int System.IComparable.CompareTo(object obj);
+        TypeCode System.IConvertible.GetTypeCode();
+        bool System.IConvertible.ToBoolean(IFormatProvider provider);
+        byte System.IConvertible.ToByte(IFormatProvider provider);
+        char System.IConvertible.ToChar(IFormatProvider provider);
+        DateTime System.IConvertible.ToDateTime(IFormatProvider provider);
+        Decimal System.IConvertible.ToDecimal(IFormatProvider provider);
+        double System.IConvertible.ToDouble(IFormatProvider provider);
+        short System.IConvertible.ToInt16(IFormatProvider provider);
+        int System.IConvertible.ToInt32(IFormatProvider provider);
+        long System.IConvertible.ToInt64(IFormatProvider provider);
+        sbyte System.IConvertible.ToSByte(IFormatProvider provider);
+        float System.IConvertible.ToSingle(IFormatProvider provider);
+        string System.IConvertible.ToString(IFormatProvider provider);
+        object System.IConvertible.ToType(Type type, IFormatProvider provider);
+        ushort System.IConvertible.ToUInt16(IFormatProvider provider);
+        uint System.IConvertible.ToUInt32(IFormatProvider provider);
+        ulong System.IConvertible.ToUInt64(IFormatProvider provider);
+        public override string ToString();
+        public string ToString(IFormatProvider provider);
+        public static bool TryParse(string value, out bool result);
+    }
+    public static class Buffer {
+        public static void BlockCopy(Array src, int srcOffset, Array dst, int dstOffset, int count);
+        public static int ByteLength(Array array);
+        public static byte GetByte(Array array, int index);
+        public unsafe static void MemoryCopy(void* source, void* destination, long destinationSizeInBytes, long sourceBytesToCopy);
+        public unsafe static void MemoryCopy(void* source, void* destination, ulong destinationSizeInBytes, ulong sourceBytesToCopy);
+        public static void SetByte(Array array, int index, byte value);
+    }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct Byte : IComparable, IComparable<byte>, IConvertible, IEquatable<byte>, IFormattable {
+        public const byte MaxValue = (byte)255;
+        public const byte MinValue = (byte)0;
+        public int CompareTo(byte value);
+        public int CompareTo(object value);
+        public bool Equals(byte obj);
+        public override bool Equals(object obj);
+        public override int GetHashCode();
+        public TypeCode GetTypeCode();
+        public static byte Parse(string s);
+        public static byte Parse(string s, NumberStyles style);
+        public static byte Parse(string s, NumberStyles style, IFormatProvider provider);
+        public static byte Parse(string s, IFormatProvider provider);
+        int System.IComparable.CompareTo(object value);
+        TypeCode System.IConvertible.GetTypeCode();
+        bool System.IConvertible.ToBoolean(IFormatProvider provider);
+        byte System.IConvertible.ToByte(IFormatProvider provider);
+        char System.IConvertible.ToChar(IFormatProvider provider);
+        DateTime System.IConvertible.ToDateTime(IFormatProvider provider);
+        Decimal System.IConvertible.ToDecimal(IFormatProvider provider);
+        double System.IConvertible.ToDouble(IFormatProvider provider);
+        short System.IConvertible.ToInt16(IFormatProvider provider);
+        int System.IConvertible.ToInt32(IFormatProvider provider);
+        long System.IConvertible.ToInt64(IFormatProvider provider);
+        sbyte System.IConvertible.ToSByte(IFormatProvider provider);
+        float System.IConvertible.ToSingle(IFormatProvider provider);
+        object System.IConvertible.ToType(Type type, IFormatProvider provider);
+        ushort System.IConvertible.ToUInt16(IFormatProvider provider);
+        uint System.IConvertible.ToUInt32(IFormatProvider provider);
+        ulong System.IConvertible.ToUInt64(IFormatProvider provider);
+        public override string ToString();
+        public string ToString(IFormatProvider provider);
+        public string ToString(string format);
+        public string ToString(string format, IFormatProvider provider);
+        public static bool TryParse(string s, out byte result);
+        public static bool TryParse(string s, NumberStyles style, IFormatProvider provider, out byte result);
+    }
+    public class CannotUnloadAppDomainException : SystemException {
+        public CannotUnloadAppDomainException();
+        public CannotUnloadAppDomainException(string message);
+        public CannotUnloadAppDomainException(string message, Exception innerException);
+    }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct Char : IComparable, IComparable<char>, IConvertible, IEquatable<char> {
+        public const char MaxValue = '\uFFFF';
+        public const char MinValue = '\0';
+        public int CompareTo(char value);
+        public int CompareTo(object value);
+        public static string ConvertFromUtf32(int utf32);
+        public static int ConvertToUtf32(char highSurrogate, char lowSurrogate);
+        public static int ConvertToUtf32(string s, int index);
+        public bool Equals(char obj);
+        public override bool Equals(object obj);
+        public override int GetHashCode();
+        public static double GetNumericValue(char c);
+        public static double GetNumericValue(string s, int index);
+        public TypeCode GetTypeCode();
+        public static UnicodeCategory GetUnicodeCategory(char c);
+        public static UnicodeCategory GetUnicodeCategory(string s, int index);
+        public static bool IsControl(char c);
+        public static bool IsControl(string s, int index);
+        public static bool IsDigit(char c);
+        public static bool IsDigit(string s, int index);
+        public static bool IsHighSurrogate(char c);
+        public static bool IsHighSurrogate(string s, int index);
+        public static bool IsLetter(char c);
+        public static bool IsLetter(string s, int index);
+        public static bool IsLetterOrDigit(char c);
+        public static bool IsLetterOrDigit(string s, int index);
+        public static bool IsLower(char c);
+        public static bool IsLower(string s, int index);
+        public static bool IsLowSurrogate(char c);
+        public static bool IsLowSurrogate(string s, int index);
+        public static bool IsNumber(char c);
+        public static bool IsNumber(string s, int index);
+        public static bool IsPunctuation(char c);
+        public static bool IsPunctuation(string s, int index);
+        public static bool IsSeparator(char c);
+        public static bool IsSeparator(string s, int index);
+        public static bool IsSurrogate(char c);
+        public static bool IsSurrogate(string s, int index);
+        public static bool IsSurrogatePair(char highSurrogate, char lowSurrogate);
+        public static bool IsSurrogatePair(string s, int index);
+        public static bool IsSymbol(char c);
+        public static bool IsSymbol(string s, int index);
+        public static bool IsUpper(char c);
+        public static bool IsUpper(string s, int index);
+        public static bool IsWhiteSpace(char c);
+        public static bool IsWhiteSpace(string s, int index);
+        public static char Parse(string s);
+        int System.IComparable.CompareTo(object value);
+        TypeCode System.IConvertible.GetTypeCode();
+        bool System.IConvertible.ToBoolean(IFormatProvider provider);
+        byte System.IConvertible.ToByte(IFormatProvider provider);
+        char System.IConvertible.ToChar(IFormatProvider provider);
+        DateTime System.IConvertible.ToDateTime(IFormatProvider provider);
+        Decimal System.IConvertible.ToDecimal(IFormatProvider provider);
+        double System.IConvertible.ToDouble(IFormatProvider provider);
+        short System.IConvertible.ToInt16(IFormatProvider provider);
+        int System.IConvertible.ToInt32(IFormatProvider provider);
+        long System.IConvertible.ToInt64(IFormatProvider provider);
+        sbyte System.IConvertible.ToSByte(IFormatProvider provider);
+        float System.IConvertible.ToSingle(IFormatProvider provider);
+        string System.IConvertible.ToString(IFormatProvider provider);
+        object System.IConvertible.ToType(Type type, IFormatProvider provider);
+        ushort System.IConvertible.ToUInt16(IFormatProvider provider);
+        uint System.IConvertible.ToUInt32(IFormatProvider provider);
+        ulong System.IConvertible.ToUInt64(IFormatProvider provider);
+        public static char ToLower(char c);
+        public static char ToLower(char c, CultureInfo culture);
+        public static char ToLowerInvariant(char c);
+        public override string ToString();
+        public static string ToString(char c);
+        public string ToString(IFormatProvider provider);
+        public static char ToUpper(char c);
+        public static char ToUpper(char c, CultureInfo culture);
+        public static char ToUpperInvariant(char c);
+        public static bool TryParse(string s, out char result);
+    }
+    public sealed class CLSCompliantAttribute : Attribute {
+        public CLSCompliantAttribute(bool isCompliant);
+        public bool IsCompliant { get; }
+    }
+    public delegate int Comparison<in T>(T x, T y);
+    public static class Console {
+        public static ConsoleColor BackgroundColor { get; set; }
+        public static int BufferHeight { get; set; }
+        public static int BufferWidth { get; set; }
+        public static bool CapsLock { get; }
+        public static int CursorLeft { get; set; }
+        public static int CursorSize { get; set; }
+        public static int CursorTop { get; set; }
+        public static bool CursorVisible { get; set; }
+        public static TextWriter Error { get; }
+        public static ConsoleColor ForegroundColor { get; set; }
+        public static TextReader In { get; }
+        public static Encoding InputEncoding { get; set; }
+        public static bool IsErrorRedirected { get; }
+        public static bool IsInputRedirected { get; }
+        public static bool IsOutputRedirected { get; }
+        public static bool KeyAvailable { get; }
+        public static int LargestWindowHeight { get; }
+        public static int LargestWindowWidth { get; }
+        public static bool NumberLock { get; }
+        public static TextWriter Out { get; }
+        public static Encoding OutputEncoding { get; set; }
+        public static string Title { get; set; }
+        public static bool TreatControlCAsInput { get; set; }
+        public static int WindowHeight { get; set; }
+        public static int WindowLeft { get; set; }
+        public static int WindowTop { get; set; }
+        public static int WindowWidth { get; set; }
+        public static event ConsoleCancelEventHandler CancelKeyPress;
+        public static void Beep();
+        public static void Beep(int frequency, int duration);
+        public static void Clear();
+        public static void MoveBufferArea(int sourceLeft, int sourceTop, int sourceWidth, int sourceHeight, int targetLeft, int targetTop);
+        public static void MoveBufferArea(int sourceLeft, int sourceTop, int sourceWidth, int sourceHeight, int targetLeft, int targetTop, char sourceChar, ConsoleColor sourceForeColor, ConsoleColor sourceBackColor);
+        public static Stream OpenStandardError();
+        public static Stream OpenStandardInput();
+        public static Stream OpenStandardOutput();
+        public static int Read();
+        public static ConsoleKeyInfo ReadKey();
+        public static ConsoleKeyInfo ReadKey(bool intercept);
+        public static string ReadLine();
+        public static void ResetColor();
+        public static void SetBufferSize(int width, int height);
+        public static void SetCursorPosition(int left, int top);
+        public static void SetError(TextWriter newError);
+        public static void SetIn(TextReader newIn);
+        public static void SetOut(TextWriter newOut);
+        public static void SetWindowPosition(int left, int top);
+        public static void SetWindowSize(int width, int height);
+        public static void Write(bool value);
+        public static void Write(char value);
+        public static void Write(char[] buffer);
+        public static void Write(char[] buffer, int index, int count);
+        public static void Write(Decimal value);
+        public static void Write(double value);
+        public static void Write(int value);
+        public static void Write(long value);
+        public static void Write(object value);
+        public static void Write(float value);
+        public static void Write(string s);
+        public static void Write(string format, object arg0);
+        public static void Write(string format, object arg0, object arg1);
+        public static void Write(string format, object arg0, object arg1, object arg2);
+        public static void Write(string format, params object[] arg);
+        public static void Write(uint value);
+        public static void Write(ulong value);
+        public static void WriteLine();
+        public static void WriteLine(bool value);
+        public static void WriteLine(char value);
+        public static void WriteLine(char[] buffer);
+        public static void WriteLine(char[] buffer, int index, int count);
+        public static void WriteLine(Decimal value);
+        public static void WriteLine(double value);
+        public static void WriteLine(int value);
+        public static void WriteLine(long value);
+        public static void WriteLine(object value);
+        public static void WriteLine(float value);
+        public static void WriteLine(string s);
+        public static void WriteLine(string format, object arg0);
+        public static void WriteLine(string format, object arg0, object arg1);
+        public static void WriteLine(string format, object arg0, object arg1, object arg2);
+        public static void WriteLine(string format, params object[] arg);
+        public static void WriteLine(uint value);
+        public static void WriteLine(ulong value);
+    }
+    public sealed class ConsoleCancelEventArgs : EventArgs {
+        public bool Cancel { get; set; }
+        public ConsoleSpecialKey SpecialKey { get; }
+    }
+    public delegate void ConsoleCancelEventHandler(object sender, ConsoleCancelEventArgs e);
+    public enum ConsoleColor {
+        Black = 0,
+        Blue = 9,
+        Cyan = 11,
+        DarkBlue = 1,
+        DarkCyan = 3,
+        DarkGray = 8,
+        DarkGreen = 2,
+        DarkMagenta = 5,
+        DarkRed = 4,
+        DarkYellow = 6,
+        Gray = 7,
+        Green = 10,
+        Magenta = 13,
+        Red = 12,
+        White = 15,
+        Yellow = 14,
+    }
+    public enum ConsoleKey {
+        A = 65,
+        Add = 107,
+        B = 66,
+        Backspace = 8,
+        C = 67,
+        Clear = 12,
+        D = 68,
+        D0 = 48,
+        D1 = 49,
+        D2 = 50,
+        D3 = 51,
+        D4 = 52,
+        D5 = 53,
+        D6 = 54,
+        D7 = 55,
+        D8 = 56,
+        D9 = 57,
+        Decimal = 110,
+        Delete = 46,
+        Divide = 111,
+        DownArrow = 40,
+        E = 69,
+        End = 35,
+        Enter = 13,
+        Escape = 27,
+        Execute = 43,
+        F = 70,
+        F1 = 112,
+        F10 = 121,
+        F11 = 122,
+        F12 = 123,
+        F13 = 124,
+        F14 = 125,
+        F15 = 126,
+        F16 = 127,
+        F17 = 128,
+        F18 = 129,
+        F19 = 130,
+        F2 = 113,
+        F20 = 131,
+        F21 = 132,
+        F22 = 133,
+        F23 = 134,
+        F24 = 135,
+        F3 = 114,
+        F4 = 115,
+        F5 = 116,
+        F6 = 117,
+        F7 = 118,
+        F8 = 119,
+        F9 = 120,
+        G = 71,
+        H = 72,
+        Help = 47,
+        Home = 36,
+        I = 73,
+        Insert = 45,
+        J = 74,
+        K = 75,
+        L = 76,
+        LeftArrow = 37,
+        M = 77,
+        Multiply = 106,
+        N = 78,
+        NumPad0 = 96,
+        NumPad1 = 97,
+        NumPad2 = 98,
+        NumPad3 = 99,
+        NumPad4 = 100,
+        NumPad5 = 101,
+        NumPad6 = 102,
+        NumPad7 = 103,
+        NumPad8 = 104,
+        NumPad9 = 105,
+        O = 79,
+        Oem1 = 186,
+        Oem2 = 191,
+        Oem3 = 192,
+        Oem4 = 219,
+        Oem5 = 220,
+        Oem6 = 221,
+        Oem7 = 222,
+        Oem8 = 223,
+        OemClear = 254,
+        OemComma = 188,
+        OemMinus = 189,
+        OemPeriod = 190,
+        OemPlus = 187,
+        P = 80,
+        PageDown = 34,
+        PageUp = 33,
+        Pause = 19,
+        Print = 42,
+        PrintScreen = 44,
+        Q = 81,
+        R = 82,
+        RightArrow = 39,
+        S = 83,
+        Select = 41,
+        Separator = 108,
+        Sleep = 95,
+        Spacebar = 32,
+        Subtract = 109,
+        T = 84,
+        Tab = 9,
+        U = 85,
+        UpArrow = 38,
+        V = 86,
+        W = 87,
+        X = 88,
+        Y = 89,
+        Z = 90,
+    }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential, Size=1)]
+    public struct ConsoleKeyInfo {
+        public ConsoleKeyInfo(char keyChar, ConsoleKey key, bool shift, bool alt, bool control);
+        public ConsoleKey Key { get; }
+        public char KeyChar { get; }
+        public ConsoleModifiers Modifiers { get; }
+        public bool Equals(ConsoleKeyInfo obj);
+        public override bool Equals(object value);
+        public override int GetHashCode();
+        public static bool operator ==(ConsoleKeyInfo a, ConsoleKeyInfo b);
+        public static bool operator !=(ConsoleKeyInfo a, ConsoleKeyInfo b);
+    }
+    public enum ConsoleModifiers {
+        Alt = 1,
+        Control = 4,
+        Shift = 2,
+    }
+    public enum ConsoleSpecialKey {
+        ControlBreak = 1,
+        ControlC = 0,
+    }
+    public class ContextMarshalException : SystemException {
+        public ContextMarshalException();
+        public ContextMarshalException(string message);
+        public ContextMarshalException(string message, Exception inner);
+    }
+    public class ContextStaticAttribute : Attribute {
+        public ContextStaticAttribute();
+    }
+    public static class Convert {
+        public static readonly object DBNull;
+        public static object ChangeType(object value, Type conversionType);
+        public static object ChangeType(object value, Type conversionType, IFormatProvider provider);
+        public static object ChangeType(object value, TypeCode typeCode, IFormatProvider provider);
+        public static byte[] FromBase64CharArray(char[] inArray, int offset, int length);
+        public static byte[] FromBase64String(string s);
+        public static TypeCode GetTypeCode(object value);
+        public static bool IsDBNull(object value);
+        public static int ToBase64CharArray(byte[] inArray, int offsetIn, int length, char[] outArray, int offsetOut);
+        public static string ToBase64String(byte[] inArray);
+        public static string ToBase64String(byte[] inArray, int offset, int length);
+        public static bool ToBoolean(bool value);
+        public static bool ToBoolean(byte value);
+        public static bool ToBoolean(char value);
+        public static bool ToBoolean(Decimal value);
+        public static bool ToBoolean(double value);
+        public static bool ToBoolean(short value);
+        public static bool ToBoolean(int value);
+        public static bool ToBoolean(long value);
+        public static bool ToBoolean(object value);
+        public static bool ToBoolean(object value, IFormatProvider provider);
+        public static bool ToBoolean(sbyte value);
+        public static bool ToBoolean(float value);
+        public static bool ToBoolean(string value);
+        public static bool ToBoolean(string value, IFormatProvider provider);
+        public static bool ToBoolean(ushort value);
+        public static bool ToBoolean(uint value);
+        public static bool ToBoolean(ulong value);
+        public static byte ToByte(bool value);
+        public static byte ToByte(byte value);
+        public static byte ToByte(char value);
+        public static byte ToByte(Decimal value);
+        public static byte ToByte(double value);
+        public static byte ToByte(short value);
+        public static byte ToByte(int value);
+        public static byte ToByte(long value);
+        public static byte ToByte(object value);
+        public static byte ToByte(object value, IFormatProvider provider);
+        public static byte ToByte(sbyte value);
+        public static byte ToByte(float value);
+        public static byte ToByte(string value);
+        public static byte ToByte(string value, IFormatProvider provider);
+        public static byte ToByte(string value, int fromBase);
+        public static byte ToByte(ushort value);
+        public static byte ToByte(uint value);
+        public static byte ToByte(ulong value);
+        public static char ToChar(byte value);
+        public static char ToChar(char value);
+        public static char ToChar(decimal value);
+        public static char ToChar(double value);
+        public static char ToChar(short value);
+        public static char ToChar(int value);
+        public static char ToChar(long value);
+        public static char ToChar(object value);
+        public static char ToChar(object value, IFormatProvider provider);
+        public static char ToChar(sbyte value);
+        public static char ToChar(float value);
+        public static char ToChar(string value);
+        public static char ToChar(string value, IFormatProvider provider);
+        public static char ToChar(ushort value);
+        public static char ToChar(uint value);
+        public static char ToChar(ulong value);
+        public static DateTime ToDateTime(object value);
+        public static DateTime ToDateTime(object value, IFormatProvider provider);
+        public static DateTime ToDateTime(string value);
+        public static DateTime ToDateTime(string value, IFormatProvider provider);
+        public static Decimal ToDecimal(bool value);
+        public static Decimal ToDecimal(byte value);
+        public static decimal ToDecimal(char value);
+        public static decimal ToDecimal(DateTime value);
+        public static Decimal ToDecimal(Decimal value);
+        public static Decimal ToDecimal(double value);
+        public static Decimal ToDecimal(short value);
+        public static Decimal ToDecimal(int value);
+        public static Decimal ToDecimal(long value);
+        public static Decimal ToDecimal(object value);
+        public static Decimal ToDecimal(object value, IFormatProvider provider);
+        public static Decimal ToDecimal(sbyte value);
+        public static Decimal ToDecimal(float value);
+        public static Decimal ToDecimal(string value);
+        public static Decimal ToDecimal(string value, IFormatProvider provider);
+        public static Decimal ToDecimal(ushort value);
+        public static Decimal ToDecimal(uint value);
+        public static Decimal ToDecimal(ulong value);
+        public static double ToDouble(bool value);
+        public static double ToDouble(byte value);
+        public static double ToDouble(char value);
+        public static double ToDouble(Decimal value);
+        public static double ToDouble(double value);
+        public static double ToDouble(short value);
+        public static double ToDouble(int value);
+        public static double ToDouble(long value);
+        public static double ToDouble(object value);
+        public static double ToDouble(object value, IFormatProvider provider);
+        public static double ToDouble(sbyte value);
+        public static double ToDouble(float value);
+        public static double ToDouble(string value);
+        public static double ToDouble(string value, IFormatProvider provider);
+        public static double ToDouble(ushort value);
+        public static double ToDouble(uint value);
+        public static double ToDouble(ulong value);
+        public static short ToInt16(bool value);
+        public static short ToInt16(byte value);
+        public static short ToInt16(char value);
+        public static short ToInt16(Decimal value);
+        public static short ToInt16(double value);
+        public static short ToInt16(short value);
+        public static short ToInt16(int value);
+        public static short ToInt16(long value);
+        public static short ToInt16(object value);
+        public static short ToInt16(object value, IFormatProvider provider);
+        public static short ToInt16(sbyte value);
+        public static short ToInt16(float value);
+        public static short ToInt16(string value);
+        public static short ToInt16(string value, IFormatProvider provider);
+        public static short ToInt16(string value, int fromBase);
+        public static short ToInt16(ushort value);
+        public static short ToInt16(uint value);
+        public static short ToInt16(ulong value);
+        public static int ToInt32(bool value);
+        public static int ToInt32(byte value);
+        public static int ToInt32(char value);
+        public static int ToInt32(Decimal value);
+        public static int ToInt32(double value);
+        public static int ToInt32(short value);
+        public static int ToInt32(int value);
+        public static int ToInt32(long value);
+        public static int ToInt32(object value);
+        public static int ToInt32(object value, IFormatProvider provider);
+        public static int ToInt32(sbyte value);
+        public static int ToInt32(float value);
+        public static int ToInt32(string value);
+        public static int ToInt32(string value, IFormatProvider provider);
+        public static int ToInt32(string value, int fromBase);
+        public static int ToInt32(ushort value);
+        public static int ToInt32(uint value);
+        public static int ToInt32(ulong value);
+        public static long ToInt64(bool value);
+        public static long ToInt64(byte value);
+        public static long ToInt64(char value);
+        public static long ToInt64(Decimal value);
+        public static long ToInt64(double value);
+        public static long ToInt64(short value);
+        public static long ToInt64(int value);
+        public static long ToInt64(long value);
+        public static long ToInt64(object value);
+        public static long ToInt64(object value, IFormatProvider provider);
+        public static long ToInt64(sbyte value);
+        public static long ToInt64(float value);
+        public static long ToInt64(string value);
+        public static long ToInt64(string value, IFormatProvider provider);
+        public static long ToInt64(string value, int fromBase);
+        public static long ToInt64(ushort value);
+        public static long ToInt64(uint value);
+        public static long ToInt64(ulong value);
+        public static sbyte ToSByte(bool value);
+        public static sbyte ToSByte(byte value);
+        public static sbyte ToSByte(char value);
+        public static sbyte ToSByte(Decimal value);
+        public static sbyte ToSByte(double value);
+        public static sbyte ToSByte(short value);
+        public static sbyte ToSByte(int value);
+        public static sbyte ToSByte(long value);
+        public static sbyte ToSByte(object value);
+        public static sbyte ToSByte(object value, IFormatProvider provider);
+        public static sbyte ToSByte(sbyte value);
+        public static sbyte ToSByte(float value);
+        public static sbyte ToSByte(string value);
+        public static sbyte ToSByte(string value, IFormatProvider provider);
+        public static sbyte ToSByte(string value, int fromBase);
+        public static sbyte ToSByte(ushort value);
+        public static sbyte ToSByte(uint value);
+        public static sbyte ToSByte(ulong value);
+        public static float ToSingle(bool value);
+        public static float ToSingle(byte value);
+        public static float ToSingle(char value);
+        public static float ToSingle(Decimal value);
+        public static float ToSingle(double value);
+        public static float ToSingle(short value);
+        public static float ToSingle(int value);
+        public static float ToSingle(long value);
+        public static float ToSingle(object value);
+        public static float ToSingle(object value, IFormatProvider provider);
+        public static float ToSingle(sbyte value);
+        public static float ToSingle(float value);
+        public static float ToSingle(string value);
+        public static float ToSingle(string value, IFormatProvider provider);
+        public static float ToSingle(ushort value);
+        public static float ToSingle(uint value);
+        public static float ToSingle(ulong value);
+        public static string ToString(bool value);
+        public static string ToString(bool value, IFormatProvider provider);
+        public static string ToString(byte value);
+        public static string ToString(byte value, IFormatProvider provider);
+        public static string ToString(byte value, int toBase);
+        public static string ToString(char value);
+        public static string ToString(char value, IFormatProvider provider);
+        public static string ToString(DateTime value);
+        public static string ToString(DateTime value, IFormatProvider provider);
+        public static string ToString(Decimal value);
+        public static string ToString(Decimal value, IFormatProvider provider);
+        public static string ToString(double value);
+        public static string ToString(double value, IFormatProvider provider);
+        public static string ToString(short value);
+        public static string ToString(short value, IFormatProvider provider);
+        public static string ToString(short value, int toBase);
+        public static string ToString(int value);
+        public static string ToString(int value, IFormatProvider provider);
+        public static string ToString(int value, int toBase);
+        public static string ToString(long value);
+        public static string ToString(long value, IFormatProvider provider);
+        public static string ToString(long value, int toBase);
+        public static string ToString(object value);
+        public static string ToString(object value, IFormatProvider provider);
+        public static string ToString(sbyte value);
+        public static string ToString(sbyte value, IFormatProvider provider);
+        public static string ToString(float value);
+        public static string ToString(float value, IFormatProvider provider);
+        public static string ToString(ushort value);
+        public static string ToString(ushort value, IFormatProvider provider);
+        public static string ToString(uint value);
+        public static string ToString(uint value, IFormatProvider provider);
+        public static string ToString(ulong value);
+        public static string ToString(ulong value, IFormatProvider provider);
+        public static ushort ToUInt16(bool value);
+        public static ushort ToUInt16(byte value);
+        public static ushort ToUInt16(char value);
+        public static ushort ToUInt16(Decimal value);
+        public static ushort ToUInt16(double value);
+        public static ushort ToUInt16(short value);
+        public static ushort ToUInt16(int value);
+        public static ushort ToUInt16(long value);
+        public static ushort ToUInt16(object value);
+        public static ushort ToUInt16(object value, IFormatProvider provider);
+        public static ushort ToUInt16(sbyte value);
+        public static ushort ToUInt16(float value);
+        public static ushort ToUInt16(string value);
+        public static ushort ToUInt16(string value, IFormatProvider provider);
+        public static ushort ToUInt16(string value, int fromBase);
+        public static ushort ToUInt16(ushort value);
+        public static ushort ToUInt16(uint value);
+        public static ushort ToUInt16(ulong value);
+        public static uint ToUInt32(bool value);
+        public static uint ToUInt32(byte value);
+        public static uint ToUInt32(char value);
+        public static uint ToUInt32(Decimal value);
+        public static uint ToUInt32(double value);
+        public static uint ToUInt32(short value);
+        public static uint ToUInt32(int value);
+        public static uint ToUInt32(long value);
+        public static uint ToUInt32(object value);
+        public static uint ToUInt32(object value, IFormatProvider provider);
+        public static uint ToUInt32(sbyte value);
+        public static uint ToUInt32(float value);
+        public static uint ToUInt32(string value);
+        public static uint ToUInt32(string value, IFormatProvider provider);
+        public static uint ToUInt32(string value, int fromBase);
+        public static uint ToUInt32(ushort value);
+        public static uint ToUInt32(uint value);
+        public static uint ToUInt32(ulong value);
+        public static ulong ToUInt64(bool value);
+        public static ulong ToUInt64(byte value);
+        public static ulong ToUInt64(char value);
+        public static ulong ToUInt64(Decimal value);
+        public static ulong ToUInt64(double value);
+        public static ulong ToUInt64(short value);
+        public static ulong ToUInt64(int value);
+        public static ulong ToUInt64(long value);
+        public static ulong ToUInt64(object value);
+        public static ulong ToUInt64(object value, IFormatProvider provider);
+        public static ulong ToUInt64(sbyte value);
+        public static ulong ToUInt64(float value);
+        public static ulong ToUInt64(string value);
+        public static ulong ToUInt64(string value, IFormatProvider provider);
+        public static ulong ToUInt64(string value, int fromBase);
+        public static ulong ToUInt64(ushort value);
+        public static ulong ToUInt64(uint value);
+        public static ulong ToUInt64(ulong value);
+    }
+    public delegate TOutput Converter<in TInput, out TOutput>(TInput input);
+    public sealed class DataMisalignedException : Exception {
+        public DataMisalignedException();
+        public DataMisalignedException(string message);
+        public DataMisalignedException(string message, Exception innerException);
+    }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential, Size=1)]
+    public struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable {
+        public static readonly DateTime MaxValue;
+        public static readonly DateTime MinValue;
+        public DateTime(int year, int month, int day);
+        public DateTime(int year, int month, int day, Calendar calendar);
+        public DateTime(int year, int month, int day, int hour, int minute, int second);
+        public DateTime(int year, int month, int day, int hour, int minute, int second, DateTimeKind kind);
+        public DateTime(int year, int month, int day, int hour, int minute, int second, Calendar calendar);
+        public DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond);
+        public DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, DateTimeKind kind);
+        public DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, Calendar calendar);
+        public DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, Calendar calendar, DateTimeKind kind);
+        public DateTime(long ticks);
+        public DateTime(long ticks, DateTimeKind kind);
+        public DateTime Date { get; }
+        public int Day { get; }
+        public DayOfWeek DayOfWeek { get; }
+        public int DayOfYear { get; }
+        public int Hour { get; }
+        public DateTimeKind Kind { get; }
+        public int Millisecond { get; }
+        public int Minute { get; }
+        public int Month { get; }
+        public static DateTime Now { get; }
+        public int Second { get; }
+        public long Ticks { get; }
+        public TimeSpan TimeOfDay { get; }
+        public static DateTime Today { get; }
+        public static DateTime UtcNow { get; }
+        public int Year { get; }
+        public DateTime Add(TimeSpan value);
+        public DateTime AddDays(double value);
+        public DateTime AddHours(double value);
+        public DateTime AddMilliseconds(double value);
+        public DateTime AddMinutes(double value);
+        public DateTime AddMonths(int months);
+        public DateTime AddSeconds(double value);
+        public DateTime AddTicks(long value);
+        public DateTime AddYears(int value);
+        public static int Compare(DateTime t1, DateTime t2);
+        public int CompareTo(DateTime value);
+        public int CompareTo(object value);
+        public static int DaysInMonth(int year, int month);
+        public bool Equals(DateTime value);
+        public static bool Equals(DateTime t1, DateTime t2);
+        public override bool Equals(object value);
+        public static DateTime FromBinary(long dateData);
+        public static DateTime FromFileTime(long fileTime);
+        public static DateTime FromFileTimeUtc(long fileTime);
+        public static DateTime FromOADate(double d);
+        public string[] GetDateTimeFormats();
+        public string[] GetDateTimeFormats(char format);
+        public string[] GetDateTimeFormats(char format, IFormatProvider provider);
+        public string[] GetDateTimeFormats(IFormatProvider provider);
+        public override int GetHashCode();
+        public TypeCode GetTypeCode();
+        public bool IsDaylightSavingTime();
+        public static bool IsLeapYear(int year);
+        public static DateTime operator +(DateTime d, TimeSpan t);
+        public static bool operator ==(DateTime d1, DateTime d2);
+        public static bool operator >(DateTime t1, DateTime t2);
+        public static bool operator >=(DateTime t1, DateTime t2);
+        public static bool operator !=(DateTime d1, DateTime d2);
+        public static bool operator <(DateTime t1, DateTime t2);
+        public static bool operator <=(DateTime t1, DateTime t2);
+        public static TimeSpan operator -(DateTime d1, DateTime d2);
+        public static DateTime operator -(DateTime d, TimeSpan t);
+        public static DateTime Parse(string s);
+        public static DateTime Parse(string s, IFormatProvider provider);
+        public static DateTime Parse(string s, IFormatProvider provider, DateTimeStyles styles);
+        public static DateTime ParseExact(string s, string format, IFormatProvider provider);
+        public static DateTime ParseExact(string s, string format, IFormatProvider provider, DateTimeStyles style);
+        public static DateTime ParseExact(string s, string[] formats, IFormatProvider provider, DateTimeStyles style);
+        public static DateTime SpecifyKind(DateTime value, DateTimeKind kind);
+        public TimeSpan Subtract(DateTime value);
+        public DateTime Subtract(TimeSpan value);
+        int System.IComparable.CompareTo(object value);
+        TypeCode System.IConvertible.GetTypeCode();
+        bool System.IConvertible.ToBoolean(IFormatProvider provider);
+        byte System.IConvertible.ToByte(IFormatProvider provider);
+        char System.IConvertible.ToChar(IFormatProvider provider);
+        DateTime System.IConvertible.ToDateTime(IFormatProvider provider);
+        Decimal System.IConvertible.ToDecimal(IFormatProvider provider);
+        double System.IConvertible.ToDouble(IFormatProvider provider);
+        short System.IConvertible.ToInt16(IFormatProvider provider);
+        int System.IConvertible.ToInt32(IFormatProvider provider);
+        long System.IConvertible.ToInt64(IFormatProvider provider);
+        sbyte System.IConvertible.ToSByte(IFormatProvider provider);
+        float System.IConvertible.ToSingle(IFormatProvider provider);
+        object System.IConvertible.ToType(Type type, IFormatProvider provider);
+        ushort System.IConvertible.ToUInt16(IFormatProvider provider);
+        uint System.IConvertible.ToUInt32(IFormatProvider provider);
+        ulong System.IConvertible.ToUInt64(IFormatProvider provider);
+        public long ToBinary();
+        public long ToFileTime();
+        public long ToFileTimeUtc();
+        public DateTime ToLocalTime();
+        public string ToLongDateString();
+        public string ToLongTimeString();
+        public double ToOADate();
+        public string ToShortDateString();
+        public string ToShortTimeString();
+        public override string ToString();
+        public string ToString(IFormatProvider provider);
+        public string ToString(string format);
+        public string ToString(string format, IFormatProvider provider);
+        public DateTime ToUniversalTime();
+        public static bool TryParse(string s, out DateTime result);
+        public static bool TryParse(string s, IFormatProvider provider, DateTimeStyles styles, out DateTime result);
+        public static bool TryParseExact(string s, string format, IFormatProvider provider, DateTimeStyles style, out DateTime result);
+        public static bool TryParseExact(string s, string[] formats, IFormatProvider provider, DateTimeStyles style, out DateTime result);
+    }
+    public enum DateTimeKind {
+        Local = 2,
+        Unspecified = 0,
+        Utc = 1,
+    }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential, Size=1)]
+    public struct DateTimeOffset : IComparable, IComparable<DateTimeOffset>, IEquatable<DateTimeOffset>, IFormattable {
+        public static readonly DateTimeOffset MaxValue;
+        public static readonly DateTimeOffset MinValue;
+        public DateTimeOffset(DateTime dateTime);
+        public DateTimeOffset(DateTime dateTime, TimeSpan offset);
+        public DateTimeOffset(int year, int month, int day, int hour, int minute, int second, int millisecond, Calendar calendar, TimeSpan offset);
+        public DateTimeOffset(int year, int month, int day, int hour, int minute, int second, int millisecond, TimeSpan offset);
+        public DateTimeOffset(int year, int month, int day, int hour, int minute, int second, TimeSpan offset);
+        public DateTimeOffset(long ticks, TimeSpan offset);
+        public DateTime Date { get; }
+        public DateTime DateTime { get; }
+        public int Day { get; }
+        public DayOfWeek DayOfWeek { get; }
+        public int DayOfYear { get; }
+        public int Hour { get; }
+        public DateTime LocalDateTime { get; }
+        public int Millisecond { get; }
+        public int Minute { get; }
+        public int Month { get; }
+        public static DateTimeOffset Now { get; }
+        public TimeSpan Offset { get; }
+        public int Second { get; }
+        public long Ticks { get; }
+        public TimeSpan TimeOfDay { get; }
+        public DateTime UtcDateTime { get; }
+        public static DateTimeOffset UtcNow { get; }
+        public long UtcTicks { get; }
+        public int Year { get; }
+        public DateTimeOffset Add(TimeSpan timeSpan);
+        public DateTimeOffset AddDays(double days);
+        public DateTimeOffset AddHours(double hours);
+        public DateTimeOffset AddMilliseconds(double milliseconds);
+        public DateTimeOffset AddMinutes(double minutes);
+        public DateTimeOffset AddMonths(int months);
+        public DateTimeOffset AddSeconds(double seconds);
+        public DateTimeOffset AddTicks(long ticks);
+        public DateTimeOffset AddYears(int years);
+        public static int Compare(DateTimeOffset first, DateTimeOffset second);
+        public int CompareTo(DateTimeOffset other);
+        public bool Equals(DateTimeOffset other);
+        public static bool Equals(DateTimeOffset first, DateTimeOffset second);
+        public override bool Equals(object obj);
+        public bool EqualsExact(DateTimeOffset other);
+        public static DateTimeOffset FromFileTime(long fileTime);
+        public static DateTimeOffset FromUnixTimeMilliseconds(long milliseconds);
+        public static DateTimeOffset FromUnixTimeSeconds(long seconds);
+        public override int GetHashCode();
+        public static DateTimeOffset operator +(DateTimeOffset dateTimeOffset, TimeSpan timeSpan);
+        public static bool operator ==(DateTimeOffset left, DateTimeOffset right);
+        public static bool operator >(DateTimeOffset left, DateTimeOffset right);
+        public static bool operator >=(DateTimeOffset left, DateTimeOffset right);
+        public static implicit operator DateTimeOffset (DateTime dateTime);
+        public static bool operator !=(DateTimeOffset left, DateTimeOffset right);
+        public static bool operator <(DateTimeOffset left, DateTimeOffset right);
+        public static bool operator <=(DateTimeOffset left, DateTimeOffset right);
+        public static TimeSpan operator -(DateTimeOffset left, DateTimeOffset right);
+        public static DateTimeOffset operator -(DateTimeOffset dateTimeOffset, TimeSpan timeSpan);
+        public static DateTimeOffset Parse(string input);
+        public static DateTimeOffset Parse(string input, IFormatProvider formatProvider);
+        public static DateTimeOffset Parse(string input, IFormatProvider formatProvider, DateTimeStyles styles);
+        public static DateTimeOffset ParseExact(string input, string format, IFormatProvider formatProvider);
+        public static DateTimeOffset ParseExact(string input, string format, IFormatProvider formatProvider, DateTimeStyles styles);
+        public static DateTimeOffset ParseExact(string input, string[] formats, IFormatProvider formatProvider, DateTimeStyles styles);
+        public TimeSpan Subtract(DateTimeOffset value);
+        public DateTimeOffset Subtract(TimeSpan value);
+        int System.IComparable.CompareTo(object obj);
+        public long ToFileTime();
+        public DateTimeOffset ToLocalTime();
+        public DateTimeOffset ToOffset(TimeSpan offset);
+        public override string ToString();
+        public string ToString(IFormatProvider formatProvider);
+        public string ToString(string format);
+        public string ToString(string format, IFormatProvider formatProvider);
+        public DateTimeOffset ToUniversalTime();
+        public long ToUnixTimeMilliseconds();
+        public long ToUnixTimeSeconds();
+        public static bool TryParse(string input, out DateTimeOffset result);
+        public static bool TryParse(string input, IFormatProvider formatProvider, DateTimeStyles styles, out DateTimeOffset result);
+        public static bool TryParseExact(string input, string format, IFormatProvider formatProvider, DateTimeStyles styles, out DateTimeOffset result);
+        public static bool TryParseExact(string input, string[] formats, IFormatProvider formatProvider, DateTimeStyles styles, out DateTimeOffset result);
+    }
+    public enum DayOfWeek {
+        Friday = 5,
+        Monday = 1,
+        Saturday = 6,
+        Sunday = 0,
+        Thursday = 4,
+        Tuesday = 2,
+        Wednesday = 3,
+    }
+    public sealed class DBNull : IConvertible {
+        public static readonly DBNull Value;
+        public TypeCode GetTypeCode();
+        bool System.IConvertible.ToBoolean(IFormatProvider provider);
+        byte System.IConvertible.ToByte(IFormatProvider provider);
+        char System.IConvertible.ToChar(IFormatProvider provider);
+        DateTime System.IConvertible.ToDateTime(IFormatProvider provider);
+        decimal System.IConvertible.ToDecimal(IFormatProvider provider);
+        double System.IConvertible.ToDouble(IFormatProvider provider);
+        short System.IConvertible.ToInt16(IFormatProvider provider);
+        int System.IConvertible.ToInt32(IFormatProvider provider);
+        long System.IConvertible.ToInt64(IFormatProvider provider);
+        sbyte System.IConvertible.ToSByte(IFormatProvider provider);
+        float System.IConvertible.ToSingle(IFormatProvider provider);
+        object System.IConvertible.ToType(Type type, IFormatProvider provider);
+        ushort System.IConvertible.ToUInt16(IFormatProvider provider);
+        uint System.IConvertible.ToUInt32(IFormatProvider provider);
+        ulong System.IConvertible.ToUInt64(IFormatProvider provider);
+        public override string ToString();
+        public string ToString(IFormatProvider provider);
+    }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct Decimal : IComparable, IComparable<Decimal>, IConvertible, IEquatable<Decimal>, IFormattable {
+        public static readonly Decimal MaxValue;
+        public static readonly Decimal MinusOne;
+        public static readonly Decimal MinValue;
+        public static readonly Decimal One;
+        public static readonly Decimal Zero;
+        public Decimal(double value);
+        public Decimal(int value);
+        public Decimal(int lo, int mid, int hi, bool isNegative, byte scale);
+        public Decimal(int[] bits);
+        public Decimal(long value);
+        public Decimal(float value);
+        public Decimal(uint value);
+        public Decimal(ulong value);
+        public static Decimal Add(Decimal d1, Decimal d2);
+        public static Decimal Ceiling(Decimal d);
+        public static int Compare(Decimal d1, Decimal d2);
+        public int CompareTo(Decimal value);
+        public int CompareTo(object value);
+        public static Decimal Divide(Decimal d1, Decimal d2);
+        public bool Equals(Decimal value);
+        public static bool Equals(Decimal d1, Decimal d2);
+        public override bool Equals(object value);
+        public static Decimal Floor(Decimal d);
+        public static int[] GetBits(Decimal d);
+        public override int GetHashCode();
+        public TypeCode GetTypeCode();
+        public static Decimal Multiply(Decimal d1, Decimal d2);
+        public static Decimal Negate(Decimal d);
+        public static Decimal operator +(Decimal d1, Decimal d2);
+        public static Decimal operator --(Decimal d);
+        public static Decimal operator /(Decimal d1, Decimal d2);
+        public static bool operator ==(Decimal d1, Decimal d2);
+        public static explicit operator byte (Decimal value);
+        public static explicit operator sbyte (Decimal value);
+        public static explicit operator char (Decimal value);
+        public static explicit operator short (Decimal value);
+        public static explicit operator ushort (Decimal value);
+        public static explicit operator int (Decimal value);
+        public static explicit operator uint (Decimal value);
+        public static explicit operator long (Decimal value);
+        public static explicit operator ulong (Decimal value);
+        public static explicit operator float (Decimal value);
+        public static explicit operator double (Decimal value);
+        public static explicit operator Decimal (double value);
+        public static explicit operator Decimal (float value);
+        public static bool operator >(Decimal d1, Decimal d2);
+        public static bool operator >=(Decimal d1, Decimal d2);
+        public static implicit operator Decimal (byte value);
+        public static implicit operator Decimal (char value);
+        public static implicit operator Decimal (short value);
+        public static implicit operator Decimal (int value);
+        public static implicit operator Decimal (long value);
+        public static implicit operator Decimal (sbyte value);
+        public static implicit operator Decimal (ushort value);
+        public static implicit operator Decimal (uint value);
+        public static implicit operator Decimal (ulong value);
+        public static Decimal operator ++(Decimal d);
+        public static bool operator !=(Decimal d1, Decimal d2);
+        public static bool operator <(Decimal d1, Decimal d2);
+        public static bool operator <=(Decimal d1, Decimal d2);
+        public static Decimal operator %(Decimal d1, Decimal d2);
+        public static Decimal operator *(Decimal d1, Decimal d2);
+        public static Decimal operator -(Decimal d1, Decimal d2);
+        public static Decimal operator -(Decimal d);
+        public static Decimal operator +(Decimal d);
+        public static Decimal Parse(string s);
+        public static Decimal Parse(string s, NumberStyles style);
+        public static Decimal Parse(string s, NumberStyles style, IFormatProvider provider);
+        public static Decimal Parse(string s, IFormatProvider provider);
+        public static Decimal Remainder(Decimal d1, Decimal d2);
+        public static decimal Round(decimal d, int decimals);
+        public static Decimal Subtract(Decimal d1, Decimal d2);
+        int System.IComparable.CompareTo(object value);
+        TypeCode System.IConvertible.GetTypeCode();
+        bool System.IConvertible.ToBoolean(IFormatProvider provider);
+        byte System.IConvertible.ToByte(IFormatProvider provider);
+        char System.IConvertible.ToChar(IFormatProvider provider);
+        DateTime System.IConvertible.ToDateTime(IFormatProvider provider);
+        Decimal System.IConvertible.ToDecimal(IFormatProvider provider);
+        double System.IConvertible.ToDouble(IFormatProvider provider);
+        short System.IConvertible.ToInt16(IFormatProvider provider);
+        int System.IConvertible.ToInt32(IFormatProvider provider);
+        long System.IConvertible.ToInt64(IFormatProvider provider);
+        sbyte System.IConvertible.ToSByte(IFormatProvider provider);
+        float System.IConvertible.ToSingle(IFormatProvider provider);
+        object System.IConvertible.ToType(Type type, IFormatProvider provider);
+        ushort System.IConvertible.ToUInt16(IFormatProvider provider);
+        uint System.IConvertible.ToUInt32(IFormatProvider provider);
+        ulong System.IConvertible.ToUInt64(IFormatProvider provider);
+        public static byte ToByte(Decimal value);
+        public static double ToDouble(Decimal d);
+        public static short ToInt16(Decimal value);
+        public static int ToInt32(Decimal d);
+        public static long ToInt64(Decimal d);
+        public static sbyte ToSByte(Decimal value);
+        public static float ToSingle(Decimal d);
+        public override string ToString();
+        public string ToString(IFormatProvider provider);
+        public string ToString(string format);
+        public string ToString(string format, IFormatProvider provider);
+        public static ushort ToUInt16(Decimal value);
+        public static uint ToUInt32(Decimal d);
+        public static ulong ToUInt64(Decimal d);
+        public static Decimal Truncate(Decimal d);
+        public static bool TryParse(string s, out Decimal result);
+        public static bool TryParse(string s, NumberStyles style, IFormatProvider provider, out Decimal result);
+    }
+    public abstract class Delegate {
+        protected Delegate(object target, string method);
+        protected Delegate(Type target, string method);
+        public MethodInfo Method { get; }
+        public object Target { get; }
+        public static Delegate Combine(Delegate a, Delegate b);
+        public static Delegate Combine(params Delegate[] delegates);
+        protected virtual Delegate CombineImpl(Delegate d);
+        public static Delegate CreateDelegate(Type type, object firstArgument, MethodInfo method);
+        [MethodImpl(NoInlining)]public static Delegate CreateDelegate(Type type, object firstArgument, MethodInfo method, bool throwOnBindFailure);
+        public static Delegate CreateDelegate(Type type, object target, string method);
+        public static Delegate CreateDelegate(Type type, object target, string method, bool ignoreCase);
+        public static Delegate CreateDelegate(Type type, object target, string method, bool ignoreCase, bool throwOnBindFailure);
+        public static Delegate CreateDelegate(Type type, MethodInfo method);
+        [MethodImpl(NoInlining)]public static Delegate CreateDelegate(Type type, MethodInfo method, bool throwOnBindFailure);
+        public static Delegate CreateDelegate(Type type, Type target, string method);
+        public static Delegate CreateDelegate(Type type, Type target, string method, bool ignoreCase);
+        public static Delegate CreateDelegate(Type type, Type target, string method, bool ignoreCase, bool throwOnBindFailure);
+        public object DynamicInvoke(params object[] args);
+        public override bool Equals(object obj);
+        public override int GetHashCode();
+        public virtual Delegate[] GetInvocationList();
+        public static bool operator ==(Delegate d1, Delegate d2);
+        public static bool operator !=(Delegate d1, Delegate d2);
+        public static Delegate Remove(Delegate source, Delegate value);
+        public static Delegate RemoveAll(Delegate source, Delegate value);
+        protected virtual Delegate RemoveImpl(Delegate d);
+    }
+    public class DivideByZeroException : ArithmeticException {
+        public DivideByZeroException();
+        public DivideByZeroException(string message);
+        public DivideByZeroException(string message, Exception innerException);
+    }
+    public class DllNotFoundException : TypeLoadException {
+        public DllNotFoundException();
+        public DllNotFoundException(string message);
+        public DllNotFoundException(string message, Exception inner);
+    }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct Double : IComparable, IComparable<double>, IConvertible, IEquatable<double>, IFormattable {
+        public const double Epsilon = 4.94065645841247E-324;
+        public const double MaxValue = 1.7976931348623157E+308;
+        public const double MinValue = -1.7976931348623157E+308;
+        public const double NaN = 0.0 / 0.0;
+        public const double NegativeInfinity = -1.0 / 0.0;
+        public const double PositiveInfinity = 1.0 / 0.0;
+        public int CompareTo(double value);
+        public int CompareTo(object value);
+        public bool Equals(double obj);
+        public override bool Equals(object obj);
+        public override int GetHashCode();
+        public TypeCode GetTypeCode();
+        public static bool IsInfinity(double d);
+        public static bool IsNaN(double d);
+        public static bool IsNegativeInfinity(double d);
+        public static bool IsPositiveInfinity(double d);
+        public static bool operator ==(double left, double right);
+        public static bool operator >(double left, double right);
+        public static bool operator >=(double left, double right);
+        public static bool operator !=(double left, double right);
+        public static bool operator <(double left, double right);
+        public static bool operator <=(double left, double right);
+        public static double Parse(string s);
+        public static double Parse(string s, NumberStyles style);
+        public static double Parse(string s, NumberStyles style, IFormatProvider provider);
+        public static double Parse(string s, IFormatProvider provider);
+        int System.IComparable.CompareTo(object value);
+        TypeCode System.IConvertible.GetTypeCode();
+        bool System.IConvertible.ToBoolean(IFormatProvider provider);
+        byte System.IConvertible.ToByte(IFormatProvider provider);
+        char System.IConvertible.ToChar(IFormatProvider provider);
+        DateTime System.IConvertible.ToDateTime(IFormatProvider provider);
+        Decimal System.IConvertible.ToDecimal(IFormatProvider provider);
+        double System.IConvertible.ToDouble(IFormatProvider provider);
+        short System.IConvertible.ToInt16(IFormatProvider provider);
+        int System.IConvertible.ToInt32(IFormatProvider provider);
+        long System.IConvertible.ToInt64(IFormatProvider provider);
+        sbyte System.IConvertible.ToSByte(IFormatProvider provider);
+        float System.IConvertible.ToSingle(IFormatProvider provider);
+        object System.IConvertible.ToType(Type type, IFormatProvider provider);
+        ushort System.IConvertible.ToUInt16(IFormatProvider provider);
+        uint System.IConvertible.ToUInt32(IFormatProvider provider);
+        ulong System.IConvertible.ToUInt64(IFormatProvider provider);
+        public override string ToString();
+        public string ToString(IFormatProvider provider);
+        public string ToString(string format);
+        public string ToString(string format, IFormatProvider provider);
+        public static bool TryParse(string s, out double result);
+        public static bool TryParse(string s, NumberStyles style, IFormatProvider provider, out double result);
+    }
+    public class EntryPointNotFoundException : TypeLoadException {
+        public EntryPointNotFoundException();
+        public EntryPointNotFoundException(string message);
+        public EntryPointNotFoundException(string message, Exception inner);
+    }
+    public abstract class Enum : ValueType, IComparable, IConvertible, IFormattable {
+        protected Enum();
+        public int CompareTo(object target);
+        public override bool Equals(object obj);
+        public static string Format(Type enumType, object value, string format);
+        public override int GetHashCode();
+        public static string GetName(Type enumType, object value);
+        public static string[] GetNames(Type enumType);
+        public TypeCode GetTypeCode();
+        public static Type GetUnderlyingType(Type enumType);
+        public static Array GetValues(Type enumType);
+        public bool HasFlag(Enum flag);
+        public static bool IsDefined(Type enumType, object value);
+        public static object Parse(Type enumType, string value);
+        public static object Parse(Type enumType, string value, bool ignoreCase);
+        TypeCode System.IConvertible.GetTypeCode();
+        bool System.IConvertible.ToBoolean(IFormatProvider provider);
+        byte System.IConvertible.ToByte(IFormatProvider provider);
+        char System.IConvertible.ToChar(IFormatProvider provider);
+        DateTime System.IConvertible.ToDateTime(IFormatProvider provider);
+        Decimal System.IConvertible.ToDecimal(IFormatProvider provider);
+        double System.IConvertible.ToDouble(IFormatProvider provider);
+        short System.IConvertible.ToInt16(IFormatProvider provider);
+        int System.IConvertible.ToInt32(IFormatProvider provider);
+        long System.IConvertible.ToInt64(IFormatProvider provider);
+        sbyte System.IConvertible.ToSByte(IFormatProvider provider);
+        float System.IConvertible.ToSingle(IFormatProvider provider);
+        string System.IConvertible.ToString(IFormatProvider provider);
+        object System.IConvertible.ToType(Type type, IFormatProvider provider);
+        ushort System.IConvertible.ToUInt16(IFormatProvider provider);
+        uint System.IConvertible.ToUInt32(IFormatProvider provider);
+        ulong System.IConvertible.ToUInt64(IFormatProvider provider);
+        string System.IFormattable.ToString(string format, IFormatProvider provider);
+        public static object ToObject(Type enumType, object value);
+        public override string ToString();
+        public string ToString(IFormatProvider provider);
+        public string ToString(string format);
+        public string ToString(string format, IFormatProvider provider);
+        public static bool TryParse<TEnum>(string value, bool ignoreCase, out TEnum result) where TEnum : struct, ValueType;
+        public static bool TryParse<TEnum>(string value, out TEnum result) where TEnum : struct, ValueType;
+    }
+    public static class Environment {
+        public static int CurrentManagedThreadId { get; }
+        public static int ExitCode { [MethodImpl(InternalCall)]get; [MethodImpl(InternalCall)]set; }
+        public static bool HasShutdownStarted { get; }
+        public static string MachineName { get; }
+        public static string NewLine { get; }
+        public static OperatingSystem OSVersion { get; }
+        public static int ProcessorCount { get; }
+        public static string StackTrace { get; }
+        public static int TickCount { get; }
+        public static Version Version { get; }
+        public static void Exit(int exitCode);
+        public static string ExpandEnvironmentVariables(string name);
+        public static void FailFast(string message);
+        public static void FailFast(string message, Exception exception);
+        public static string[] GetCommandLineArgs();
+        public static string GetEnvironmentVariable(string variable);
+        public static IDictionary GetEnvironmentVariables();
+        public static void SetEnvironmentVariable(string variable, string value);
+    }
+    public class EventArgs {
+        public static readonly EventArgs Empty;
+        public EventArgs();
+    }
+    public delegate void EventHandler(object sender, EventArgs e);
+    public delegate void EventHandler<TEventArgs>(object sender, TEventArgs e);
+    public class Exception {
+        public Exception();
+        public Exception(string message);
+        public Exception(string message, Exception innerException);
+        public virtual IDictionary Data { get; }
+        public virtual string HelpLink { get; set; }
+        public int HResult { get; protected set; }
+        public Exception InnerException { get; }
+        public virtual string Message { get; }
+        public virtual string Source { get; set; }
+        public virtual string StackTrace { get; }
+        public virtual Exception GetBaseException();
+        public override string ToString();
+    }
+    public sealed class ExecutionEngineException : SystemException
+    public class FieldAccessException : MemberAccessException {
+        public FieldAccessException();
+        public FieldAccessException(string message);
+        public FieldAccessException(string message, Exception inner);
+    }
+    public class FlagsAttribute : Attribute {
+        public FlagsAttribute();
+    }
+    public class FormatException : Exception {
+        public FormatException();
+        public FormatException(string message);
+        public FormatException(string message, Exception innerException);
+    }
+    public abstract class FormattableString : IFormattable {
+        protected FormattableString();
+        public abstract int ArgumentCount { get; }
+        public abstract string Format { get; }
+        public abstract object GetArgument(int index);
+        public abstract object[] GetArguments();
+        public static string Invariant(FormattableString formattable);
+        string System.IFormattable.ToString(string ignored, IFormatProvider formatProvider);
+        public override string ToString();
+        public abstract string ToString(IFormatProvider formatProvider);
+    }
+    public delegate TResult Func<out TResult>();
+    public delegate TResult Func<in T, out TResult>(T arg);
+    public delegate TResult Func<in T1, in T2, out TResult>(T1 arg1, T2 arg2);
+    public delegate TResult Func<in T1, in T2, in T3, out TResult>(T1 arg1, T2 arg2, T3 arg3);
+    public delegate TResult Func<in T1, in T2, in T3, in T4, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4);
+    public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5);
+    public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, in T6, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6);
+    public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, in T6, in T7, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7);
+    public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8);
+    public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9);
+    public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10);
+    public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11);
+    public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, in T12, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12);
+    public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, in T12, in T13, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13);
+    public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, in T12, in T13, in T14, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14);
+    public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, in T12, in T13, in T14, in T15, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15);
+    public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, in T12, in T13, in T14, in T15, in T16, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16);
+    public static class GC {
+        public static int MaxGeneration { get; }
+        public static void AddMemoryPressure(long bytesAllocated);
+        public static void Collect();
+        public static void Collect(int generation);
+        public static void Collect(int generation, GCCollectionMode mode);
+        public static void Collect(int generation, GCCollectionMode mode, bool blocking);
+        public static void Collect(int generation, GCCollectionMode mode, bool blocking, bool compacting);
+        public static int CollectionCount(int generation);
+        public static int GetGeneration(object obj);
+        public static long GetTotalMemory(bool forceFullCollection);
+        public static void KeepAlive(object obj);
+        public static void RemoveMemoryPressure(long bytesAllocated);
+        public static void ReRegisterForFinalize(object obj);
+        public static void SuppressFinalize(object obj);
+        public static void WaitForPendingFinalizers();
+    }
+    public enum GCCollectionMode {
+        Default = 0,
+        Forced = 1,
+        Optimized = 2,
+    }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct Guid : IComparable, IComparable<Guid>, IEquatable<Guid>, IFormattable {
+        public static readonly Guid Empty;
+        public Guid(byte[] b);
+        public Guid(int a, short b, short c, byte d, byte e, byte f, byte g, byte h, byte i, byte j, byte k);
+        public Guid(int a, short b, short c, byte[] d);
+        public Guid(string g);
+        public Guid(uint a, ushort b, ushort c, byte d, byte e, byte f, byte g, byte h, byte i, byte j, byte k);
+        public int CompareTo(Guid value);
+        public int CompareTo(object value);
+        public bool Equals(Guid g);
+        public override bool Equals(object o);
+        public override int GetHashCode();
+        public static Guid NewGuid();
+        public static bool operator ==(Guid a, Guid b);
+        public static bool operator !=(Guid a, Guid b);
+        public static Guid Parse(string input);
+        public static Guid ParseExact(string input, string format);
+        int System.IComparable.CompareTo(object value);
+        string System.IFormattable.ToString(string format, IFormatProvider provider);
+        public byte[] ToByteArray();
+        public override string ToString();
+        public string ToString(string format);
+        public string ToString(string format, IFormatProvider provider);
+        public static bool TryParse(string input, out Guid result);
+        public static bool TryParseExact(string input, string format, out Guid result);
+    }
+    public interface IAsyncResult {
+        object AsyncState { get; }
+        WaitHandle AsyncWaitHandle { get; }
+        bool CompletedSynchronously { get; }
+        bool IsCompleted { get; }
+    }
+    public interface IComparable {
+        int CompareTo(object obj);
+    }
+    public interface IComparable<in T> {
+        int CompareTo(T other);
+    }
+    public interface IConvertible {
+        TypeCode GetTypeCode();
+        bool ToBoolean(IFormatProvider provider);
+        byte ToByte(IFormatProvider provider);
+        char ToChar(IFormatProvider provider);
+        DateTime ToDateTime(IFormatProvider provider);
+        Decimal ToDecimal(IFormatProvider provider);
+        double ToDouble(IFormatProvider provider);
+        short ToInt16(IFormatProvider provider);
+        int ToInt32(IFormatProvider provider);
+        long ToInt64(IFormatProvider provider);
+        sbyte ToSByte(IFormatProvider provider);
+        float ToSingle(IFormatProvider provider);
+        string ToString(IFormatProvider provider);
+        object ToType(Type conversionType, IFormatProvider provider);
+        ushort ToUInt16(IFormatProvider provider);
+        uint ToUInt32(IFormatProvider provider);
+        ulong ToUInt64(IFormatProvider provider);
+    }
+    public interface ICustomFormatter {
+        string Format(string format, object arg, IFormatProvider formatProvider);
+    }
+    public interface IDisposable {
+        void Dispose();
+    }
+    public interface IEquatable<T> {
+        bool Equals(T other);
+    }
+    public interface IFormatProvider {
+        object GetFormat(Type formatType);
+    }
+    public interface IFormattable {
+        string ToString(string format, IFormatProvider formatProvider);
+    }
+    public sealed class IndexOutOfRangeException : Exception {
+        public IndexOutOfRangeException();
+        public IndexOutOfRangeException(string message);
+        public IndexOutOfRangeException(string message, Exception innerException);
+    }
+    public sealed class InsufficientExecutionStackException : Exception {
+        public InsufficientExecutionStackException();
+        public InsufficientExecutionStackException(string message);
+        public InsufficientExecutionStackException(string message, Exception innerException);
+    }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct Int16 : IComparable, IComparable<short>, IConvertible, IEquatable<short>, IFormattable {
+        public const short MaxValue = (short)32767;
+        public const short MinValue = (short)-32768;
+        public int CompareTo(short value);
+        public int CompareTo(object value);
+        public bool Equals(short obj);
+        public override bool Equals(object obj);
+        public override int GetHashCode();
+        public TypeCode GetTypeCode();
+        public static short Parse(string s);
+        public static short Parse(string s, NumberStyles style);
+        public static short Parse(string s, NumberStyles style, IFormatProvider provider);
+        public static short Parse(string s, IFormatProvider provider);
+        int System.IComparable.CompareTo(object value);
+        TypeCode System.IConvertible.GetTypeCode();
+        bool System.IConvertible.ToBoolean(IFormatProvider provider);
+        byte System.IConvertible.ToByte(IFormatProvider provider);
+        char System.IConvertible.ToChar(IFormatProvider provider);
+        DateTime System.IConvertible.ToDateTime(IFormatProvider provider);
+        Decimal System.IConvertible.ToDecimal(IFormatProvider provider);
+        double System.IConvertible.ToDouble(IFormatProvider provider);
+        short System.IConvertible.ToInt16(IFormatProvider provider);
+        int System.IConvertible.ToInt32(IFormatProvider provider);
+        long System.IConvertible.ToInt64(IFormatProvider provider);
+        sbyte System.IConvertible.ToSByte(IFormatProvider provider);
+        float System.IConvertible.ToSingle(IFormatProvider provider);
+        object System.IConvertible.ToType(Type type, IFormatProvider provider);
+        ushort System.IConvertible.ToUInt16(IFormatProvider provider);
+        uint System.IConvertible.ToUInt32(IFormatProvider provider);
+        ulong System.IConvertible.ToUInt64(IFormatProvider provider);
+        public override string ToString();
+        public string ToString(IFormatProvider provider);
+        public string ToString(string format);
+        public string ToString(string format, IFormatProvider provider);
+        public static bool TryParse(string s, NumberStyles style, IFormatProvider provider, out short result);
+        public static bool TryParse(string s, out short result);
+    }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct Int32 : IComparable, IComparable<int>, IConvertible, IEquatable<int>, IFormattable {
+        public const int MaxValue = 2147483647;
+        public const int MinValue = -2147483648;
+        public int CompareTo(int value);
+        public int CompareTo(object value);
+        public bool Equals(int obj);
+        public override bool Equals(object obj);
+        public override int GetHashCode();
+        public TypeCode GetTypeCode();
+        public static int Parse(string s);
+        public static int Parse(string s, NumberStyles style);
+        public static int Parse(string s, NumberStyles style, IFormatProvider provider);
+        public static int Parse(string s, IFormatProvider provider);
+        int System.IComparable.CompareTo(object value);
+        TypeCode System.IConvertible.GetTypeCode();
+        bool System.IConvertible.ToBoolean(IFormatProvider provider);
+        byte System.IConvertible.ToByte(IFormatProvider provider);
+        char System.IConvertible.ToChar(IFormatProvider provider);
+        DateTime System.IConvertible.ToDateTime(IFormatProvider provider);
+        Decimal System.IConvertible.ToDecimal(IFormatProvider provider);
+        double System.IConvertible.ToDouble(IFormatProvider provider);
+        short System.IConvertible.ToInt16(IFormatProvider provider);
+        int System.IConvertible.ToInt32(IFormatProvider provider);
+        long System.IConvertible.ToInt64(IFormatProvider provider);
+        sbyte System.IConvertible.ToSByte(IFormatProvider provider);
+        float System.IConvertible.ToSingle(IFormatProvider provider);
+        object System.IConvertible.ToType(Type type, IFormatProvider provider);
+        ushort System.IConvertible.ToUInt16(IFormatProvider provider);
+        uint System.IConvertible.ToUInt32(IFormatProvider provider);
+        ulong System.IConvertible.ToUInt64(IFormatProvider provider);
+        public override string ToString();
+        public string ToString(IFormatProvider provider);
+        public string ToString(string format);
+        public string ToString(string format, IFormatProvider provider);
+        public static bool TryParse(string s, NumberStyles style, IFormatProvider provider, out int result);
+        public static bool TryParse(string s, out int result);
+    }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct Int64 : IComparable, IComparable<long>, IConvertible, IEquatable<long>, IFormattable {
+        public const long MaxValue = (long)9223372036854775807;
+        public const long MinValue = (long)-9223372036854775808;
+        public int CompareTo(long value);
+        public int CompareTo(object value);
+        public bool Equals(long obj);
+        public override bool Equals(object obj);
+        public override int GetHashCode();
+        public TypeCode GetTypeCode();
+        public static long Parse(string s);
+        public static long Parse(string s, NumberStyles style);
+        public static long Parse(string s, NumberStyles style, IFormatProvider provider);
+        public static long Parse(string s, IFormatProvider provider);
+        int System.IComparable.CompareTo(object value);
+        TypeCode System.IConvertible.GetTypeCode();
+        bool System.IConvertible.ToBoolean(IFormatProvider provider);
+        byte System.IConvertible.ToByte(IFormatProvider provider);
+        char System.IConvertible.ToChar(IFormatProvider provider);
+        DateTime System.IConvertible.ToDateTime(IFormatProvider provider);
+        Decimal System.IConvertible.ToDecimal(IFormatProvider provider);
+        double System.IConvertible.ToDouble(IFormatProvider provider);
+        short System.IConvertible.ToInt16(IFormatProvider provider);
+        int System.IConvertible.ToInt32(IFormatProvider provider);
+        long System.IConvertible.ToInt64(IFormatProvider provider);
+        sbyte System.IConvertible.ToSByte(IFormatProvider provider);
+        float System.IConvertible.ToSingle(IFormatProvider provider);
+        object System.IConvertible.ToType(Type type, IFormatProvider provider);
+        ushort System.IConvertible.ToUInt16(IFormatProvider provider);
+        uint System.IConvertible.ToUInt32(IFormatProvider provider);
+        ulong System.IConvertible.ToUInt64(IFormatProvider provider);
+        public override string ToString();
+        public string ToString(IFormatProvider provider);
+        public string ToString(string format);
+        public string ToString(string format, IFormatProvider provider);
+        public static bool TryParse(string s, NumberStyles style, IFormatProvider provider, out long result);
+        public static bool TryParse(string s, out long result);
+    }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct IntPtr {
+        public static readonly IntPtr Zero;
+        public IntPtr(int value);
+        public IntPtr(long value);
+        public unsafe IntPtr(void* value);
+        public static int Size { get; }
+        public static IntPtr Add(IntPtr pointer, int offset);
+        public override bool Equals(object obj);
+        public override int GetHashCode();
+        public static IntPtr operator +(IntPtr pointer, int offset);
+        public static bool operator ==(IntPtr value1, IntPtr value2);
+        public static explicit operator IntPtr (int value);
+        public static explicit operator IntPtr (long value);
+        public unsafe static explicit operator void* (IntPtr value);
+        public static explicit operator int (IntPtr value);
+        public static explicit operator long (IntPtr value);
+        public unsafe static explicit operator IntPtr (void* value);
+        public static bool operator !=(IntPtr value1, IntPtr value2);
+        public static IntPtr operator -(IntPtr pointer, int offset);
+        public static IntPtr Subtract(IntPtr pointer, int offset);
+        public int ToInt32();
+        public long ToInt64();
+        public unsafe void* ToPointer();
+        public override string ToString();
+        public string ToString(string format);
+    }
+    public class InvalidCastException : Exception {
+        public InvalidCastException();
+        public InvalidCastException(string message);
+        public InvalidCastException(string message, Exception innerException);
+        public InvalidCastException(string message, int errorCode);
+    }
+    public class InvalidOperationException : Exception {
+        public InvalidOperationException();
+        public InvalidOperationException(string message);
+        public InvalidOperationException(string message, Exception innerException);
+    }
+    public sealed class InvalidProgramException : Exception {
+        public InvalidProgramException();
+        public InvalidProgramException(string message);
+        public InvalidProgramException(string message, Exception inner);
+    }
+    public class InvalidTimeZoneException : Exception {
+        public InvalidTimeZoneException();
+        public InvalidTimeZoneException(string message);
+        public InvalidTimeZoneException(string message, Exception innerException);
+    }
+    public interface IObservable<out T> {
+        IDisposable Subscribe(IObserver<T> observer);
+    }
+    public interface IObserver<in T> {
+        void OnCompleted();
+        void OnError(Exception error);
+        void OnNext(T value);
+    }
+    public interface IProgress<in T> {
+        void Report(T value);
+    }
+    public interface IServiceProvider {
+        object GetService(Type serviceType);
+    }
+    public class Lazy<T> {
+        public Lazy();
+        public Lazy(bool isThreadSafe);
+        public Lazy(Func<T> valueFactory);
+        public Lazy(Func<T> valueFactory, bool isThreadSafe);
+        public Lazy(Func<T> valueFactory, LazyThreadSafetyMode mode);
+        public Lazy(LazyThreadSafetyMode mode);
+        public bool IsValueCreated { get; }
+        public T Value { get; }
+        public override string ToString();
+    }
+    public class Lazy<T, TMetadata> : Lazy<T> {
+        public Lazy(Func<T> valueFactory, TMetadata metadata);
+        public Lazy(Func<T> valueFactory, TMetadata metadata, bool isThreadSafe);
+        public Lazy(Func<T> valueFactory, TMetadata metadata, LazyThreadSafetyMode mode);
+        public Lazy(TMetadata metadata);
+        public Lazy(TMetadata metadata, bool isThreadSafe);
+        public Lazy(TMetadata metadata, LazyThreadSafetyMode mode);
+        public TMetadata Metadata { get; }
+    }
+    public static class Math {
+        public const double E = 2.7182818284590451;
+        public const double PI = 3.1415926535897931;
+        public static Decimal Abs(Decimal value);
+        public static double Abs(double value);
+        public static short Abs(short value);
+        public static int Abs(int value);
+        public static long Abs(long value);
+        public static sbyte Abs(sbyte value);
+        public static float Abs(float value);
+        public static double Acos(double d);
+        public static double Asin(double d);
+        public static double Atan(double d);
+        public static double Atan2(double y, double x);
+        public static Decimal Ceiling(Decimal d);
+        public static double Ceiling(double a);
+        public static double Cos(double d);
+        public static double Cosh(double value);
+        public static double Exp(double d);
+        public static Decimal Floor(Decimal d);
+        public static double Floor(double d);
+        public static double IEEERemainder(double x, double y);
+        public static double Log(double d);
+        public static double Log(double a, double newBase);
+        public static double Log10(double d);
+        public static byte Max(byte val1, byte val2);
+        public static Decimal Max(Decimal val1, Decimal val2);
+        public static double Max(double val1, double val2);
+        public static short Max(short val1, short val2);
+        public static int Max(int val1, int val2);
+        public static long Max(long val1, long val2);
+        public static sbyte Max(sbyte val1, sbyte val2);
+        public static float Max(float val1, float val2);
+        public static ushort Max(ushort val1, ushort val2);
+        public static uint Max(uint val1, uint val2);
+        public static ulong Max(ulong val1, ulong val2);
+        public static byte Min(byte val1, byte val2);
+        public static Decimal Min(Decimal val1, Decimal val2);
+        public static double Min(double val1, double val2);
+        public static short Min(short val1, short val2);
+        public static int Min(int val1, int val2);
+        public static long Min(long val1, long val2);
+        public static sbyte Min(sbyte val1, sbyte val2);
+        public static float Min(float val1, float val2);
+        public static ushort Min(ushort val1, ushort val2);
+        public static uint Min(uint val1, uint val2);
+        public static ulong Min(ulong val1, ulong val2);
+        public static double Pow(double x, double y);
+        public static Decimal Round(Decimal d);
+        public static Decimal Round(Decimal d, int decimals);
+        public static Decimal Round(Decimal d, int decimals, MidpointRounding mode);
+        public static Decimal Round(Decimal d, MidpointRounding mode);
+        public static double Round(double a);
+        public static double Round(double value, int digits);
+        public static double Round(double value, int digits, MidpointRounding mode);
+        public static double Round(double value, MidpointRounding mode);
+        public static int Sign(Decimal value);
+        public static int Sign(double value);
+        public static int Sign(short value);
+        public static int Sign(int value);
+        public static int Sign(long value);
+        public static int Sign(sbyte value);
+        public static int Sign(float value);
+        public static double Sin(double a);
+        public static double Sinh(double value);
+        public static double Sqrt(double d);
+        public static double Tan(double a);
+        public static double Tanh(double value);
+        public static Decimal Truncate(Decimal d);
+        public static double Truncate(double d);
+    }
+    public class MemberAccessException : Exception {
+        public MemberAccessException();
+        public MemberAccessException(string message);
+        public MemberAccessException(string message, Exception inner);
+    }
+    public class MethodAccessException : MemberAccessException {
+        public MethodAccessException();
+        public MethodAccessException(string message);
+        public MethodAccessException(string message, Exception inner);
+    }
+    public enum MidpointRounding {
+        AwayFromZero = 1,
+        ToEven = 0,
+    }
+    public class MissingFieldException : MissingMemberException {
+        public MissingFieldException();
+        public MissingFieldException(string message);
+        public MissingFieldException(string message, Exception inner);
+        public override string Message { get; }
+    }
+    public class MissingMemberException : MemberAccessException {
+        public MissingMemberException();
+        public MissingMemberException(string message);
+        public MissingMemberException(string message, Exception inner);
+        public override string Message { get; }
+    }
+    public class MissingMethodException : MissingMemberException {
+        public MissingMethodException();
+        public MissingMethodException(string message);
+        public MissingMethodException(string message, Exception inner);
+        public override string Message { get; }
+    }
+    public sealed class MTAThreadAttribute : Attribute {
+        public MTAThreadAttribute();
+    }
+    public abstract class MulticastDelegate : Delegate {
+        protected MulticastDelegate(object target, string method);
+        protected sealed override Delegate CombineImpl(Delegate follow);
+        public sealed override bool Equals(object obj);
+        public sealed override int GetHashCode();
+        public sealed override Delegate[] GetInvocationList();
+        public static bool operator ==(MulticastDelegate d1, MulticastDelegate d2);
+        public static bool operator !=(MulticastDelegate d1, MulticastDelegate d2);
+        protected sealed override Delegate RemoveImpl(Delegate value);
+    }
+    public sealed class MulticastNotSupportedException : SystemException {
+        public MulticastNotSupportedException();
+        public MulticastNotSupportedException(string message);
+        public MulticastNotSupportedException(string message, Exception inner);
+    }
+    public class NotFiniteNumberException : ArithmeticException {
+        public NotFiniteNumberException();
+        public NotFiniteNumberException(string message);
+        public NotFiniteNumberException(string message, Exception innerException);
+    }
+    public class NotImplementedException : Exception {
+        public NotImplementedException();
+        public NotImplementedException(string message);
+        public NotImplementedException(string message, Exception inner);
+    }
+    public class NotSupportedException : Exception {
+        public NotSupportedException();
+        public NotSupportedException(string message);
+        public NotSupportedException(string message, Exception innerException);
+    }
+    public static class Nullable {
+        public static int Compare<T>(Nullable<T> n1, Nullable<T> n2) where T : struct, ValueType;
+        public static bool Equals<T>(Nullable<T> n1, Nullable<T> n2) where T : struct, ValueType;
+        public static Type GetUnderlyingType(Type nullableType);
+    }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct Nullable<T> where T : struct, ValueType {
+        public Nullable(T value);
+        public bool HasValue { get; }
+        public T Value { get; }
+        public override bool Equals(object other);
+        public override int GetHashCode();
+        public T GetValueOrDefault();
+        public T GetValueOrDefault(T defaultValue);
+        public static explicit operator T (Nullable<T> value);
+        public static implicit operator Nullable<T> (T value);
+        public override string ToString();
+    }
+    public class NullReferenceException : Exception {
+        public NullReferenceException();
+        public NullReferenceException(string message);
+        public NullReferenceException(string message, Exception innerException);
+    }
+    public class Object {
+        public Object();
+        public virtual bool Equals(object obj);
+        public static bool Equals(object objA, object objB);
+        ~Object();
+        public virtual int GetHashCode();
+        public Type GetType();
+        protected object MemberwiseClone();
+        public static bool ReferenceEquals(object objA, object objB);
+        public virtual string ToString();
+    }
+    public class ObjectDisposedException : InvalidOperationException {
+        public ObjectDisposedException(string objectName);
+        public ObjectDisposedException(string message, Exception innerException);
+        public ObjectDisposedException(string objectName, string message);
+        public override string Message { get; }
+        public string ObjectName { get; }
+    }
+    public sealed class ObsoleteAttribute : Attribute {
+        public ObsoleteAttribute();
+        public ObsoleteAttribute(string message);
+        public ObsoleteAttribute(string message, bool error);
+        public bool IsError { get; }
+        public string Message { get; }
+    }
+    public sealed class OperatingSystem {
+        public OperatingSystem(PlatformID platform, Version version);
+        public PlatformID Platform { get; }
+        public Version Version { get; }
+        public object Clone();
+        public override string ToString();
+    }
+    public class OperationCanceledException : Exception {
+        public OperationCanceledException();
+        public OperationCanceledException(string message);
+        public OperationCanceledException(string message, Exception innerException);
+        public OperationCanceledException(string message, Exception innerException, CancellationToken token);
+        public OperationCanceledException(string message, CancellationToken token);
+        public OperationCanceledException(CancellationToken token);
+        public CancellationToken CancellationToken { get; }
+    }
+    public class OutOfMemoryException : Exception {
+        public OutOfMemoryException();
+        public OutOfMemoryException(string message);
+        public OutOfMemoryException(string message, Exception innerException);
+    }
+    public class OverflowException : ArithmeticException {
+        public OverflowException();
+        public OverflowException(string message);
+        public OverflowException(string message, Exception innerException);
+    }
+    public sealed class ParamArrayAttribute : Attribute {
+        public ParamArrayAttribute();
+    }
+    public enum PlatformID {
+        MacOSX = 6,
+        Unix = 4,
+        Win32NT = 2,
+        Win32S = 0,
+        Win32Windows = 1,
+        WinCE = 3,
+        Xbox = 5,
+    }
+    public class PlatformNotSupportedException : NotSupportedException {
+        public PlatformNotSupportedException();
+        public PlatformNotSupportedException(string message);
+        public PlatformNotSupportedException(string message, Exception inner);
+    }
+    public delegate bool Predicate<in T>(T obj);
+    public class Progress<T> : IProgress<T> {
+        public Progress();
+        public Progress(Action<T> handler);
+        public event EventHandler<T> ProgressChanged;
+        protected virtual void OnReport(T value);
+        void System.IProgress<T>.Report(T value);
+    }
+    public class Random {
+        public Random();
+        public Random(int Seed);
+        public virtual int Next();
+        public virtual int Next(int maxValue);
+        public virtual int Next(int minValue, int maxValue);
+        public virtual void NextBytes(byte[] buffer);
+        public virtual double NextDouble();
+        protected virtual double Sample();
+    }
+    public class RankException : Exception {
+        public RankException();
+        public RankException(string message);
+        public RankException(string message, Exception innerException);
+    }
+    public class ResolveEventArgs : EventArgs {
+        public ResolveEventArgs(string name);
+        public ResolveEventArgs(string name, Assembly requestingAssembly);
+        public string Name { get; }
+        public Assembly RequestingAssembly { get; }
+    }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct RuntimeArgumentHandle
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct RuntimeFieldHandle {
+        public override bool Equals(object obj);
+        public bool Equals(RuntimeFieldHandle handle);
+        public override int GetHashCode();
+        public static bool operator ==(RuntimeFieldHandle left, RuntimeFieldHandle right);
+        public static bool operator !=(RuntimeFieldHandle left, RuntimeFieldHandle right);
+    }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct RuntimeMethodHandle {
+        public IntPtr Value { get; }
+        public override bool Equals(object obj);
+        public bool Equals(RuntimeMethodHandle handle);
+        public override int GetHashCode();
+        public static bool operator ==(RuntimeMethodHandle left, RuntimeMethodHandle right);
+        public static bool operator !=(RuntimeMethodHandle left, RuntimeMethodHandle right);
+    }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct RuntimeTypeHandle {
+        public IntPtr Value { get; }
+        public override bool Equals(object obj);
+        public bool Equals(RuntimeTypeHandle handle);
+        public override int GetHashCode();
+        public static bool operator ==(object left, RuntimeTypeHandle right);
+        public static bool operator ==(RuntimeTypeHandle left, object right);
+        public static bool operator !=(object left, RuntimeTypeHandle right);
+        public static bool operator !=(RuntimeTypeHandle left, object right);
+    }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct SByte : IComparable, IComparable<sbyte>, IConvertible, IEquatable<sbyte>, IFormattable {
+        public const sbyte MaxValue = (sbyte)127;
+        public const sbyte MinValue = (sbyte)-128;
+        public int CompareTo(object obj);
+        public int CompareTo(sbyte value);
+        public override bool Equals(object obj);
+        public bool Equals(sbyte obj);
+        public override int GetHashCode();
+        public TypeCode GetTypeCode();
+        public static sbyte Parse(string s);
+        public static sbyte Parse(string s, NumberStyles style);
+        public static sbyte Parse(string s, NumberStyles style, IFormatProvider provider);
+        public static sbyte Parse(string s, IFormatProvider provider);
+        int System.IComparable.CompareTo(object obj);
+        TypeCode System.IConvertible.GetTypeCode();
+        bool System.IConvertible.ToBoolean(IFormatProvider provider);
+        byte System.IConvertible.ToByte(IFormatProvider provider);
+        char System.IConvertible.ToChar(IFormatProvider provider);
+        DateTime System.IConvertible.ToDateTime(IFormatProvider provider);
+        Decimal System.IConvertible.ToDecimal(IFormatProvider provider);
+        double System.IConvertible.ToDouble(IFormatProvider provider);
+        short System.IConvertible.ToInt16(IFormatProvider provider);
+        int System.IConvertible.ToInt32(IFormatProvider provider);
+        long System.IConvertible.ToInt64(IFormatProvider provider);
+        sbyte System.IConvertible.ToSByte(IFormatProvider provider);
+        float System.IConvertible.ToSingle(IFormatProvider provider);
+        object System.IConvertible.ToType(Type type, IFormatProvider provider);
+        ushort System.IConvertible.ToUInt16(IFormatProvider provider);
+        uint System.IConvertible.ToUInt32(IFormatProvider provider);
+        ulong System.IConvertible.ToUInt64(IFormatProvider provider);
+        public override string ToString();
+        public string ToString(IFormatProvider provider);
+        public string ToString(string format);
+        public string ToString(string format, IFormatProvider provider);
+        public static bool TryParse(string s, NumberStyles style, IFormatProvider provider, out sbyte result);
+        public static bool TryParse(string s, out sbyte result);
+    }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct Single : IComparable, IComparable<float>, IConvertible, IEquatable<float>, IFormattable {
+        public const float Epsilon = 1.401298E-45f;
+        public const float MaxValue = 3.40282347E+38f;
+        public const float MinValue = -3.40282347E+38f;
+        public const float NaN = 0.0f / 0.0f;
+        public const float NegativeInfinity = -1.0f / 0.0f;
+        public const float PositiveInfinity = 1.0f / 0.0f;
+        public int CompareTo(object value);
+        public int CompareTo(float value);
+        public override bool Equals(object obj);
+        public bool Equals(float obj);
+        public override int GetHashCode();
+        public TypeCode GetTypeCode();
+        public static bool IsInfinity(float f);
+        public static bool IsNaN(float f);
+        public static bool IsNegativeInfinity(float f);
+        public static bool IsPositiveInfinity(float f);
+        public static bool operator ==(float left, float right);
+        public static bool operator >(float left, float right);
+        public static bool operator >=(float left, float right);
+        public static bool operator !=(float left, float right);
+        public static bool operator <(float left, float right);
+        public static bool operator <=(float left, float right);
+        public static float Parse(string s);
+        public static float Parse(string s, NumberStyles style);
+        public static float Parse(string s, NumberStyles style, IFormatProvider provider);
+        public static float Parse(string s, IFormatProvider provider);
+        int System.IComparable.CompareTo(object value);
+        TypeCode System.IConvertible.GetTypeCode();
+        bool System.IConvertible.ToBoolean(IFormatProvider provider);
+        byte System.IConvertible.ToByte(IFormatProvider provider);
+        char System.IConvertible.ToChar(IFormatProvider provider);
+        DateTime System.IConvertible.ToDateTime(IFormatProvider provider);
+        Decimal System.IConvertible.ToDecimal(IFormatProvider provider);
+        double System.IConvertible.ToDouble(IFormatProvider provider);
+        short System.IConvertible.ToInt16(IFormatProvider provider);
+        int System.IConvertible.ToInt32(IFormatProvider provider);
+        long System.IConvertible.ToInt64(IFormatProvider provider);
+        sbyte System.IConvertible.ToSByte(IFormatProvider provider);
+        float System.IConvertible.ToSingle(IFormatProvider provider);
+        object System.IConvertible.ToType(Type type, IFormatProvider provider);
+        ushort System.IConvertible.ToUInt16(IFormatProvider provider);
+        uint System.IConvertible.ToUInt32(IFormatProvider provider);
+        ulong System.IConvertible.ToUInt64(IFormatProvider provider);
+        public override string ToString();
+        public string ToString(IFormatProvider provider);
+        public string ToString(string format);
+        public string ToString(string format, IFormatProvider provider);
+        public static bool TryParse(string s, NumberStyles style, IFormatProvider provider, out float result);
+        public static bool TryParse(string s, out float result);
+    }
+    public sealed class StackOverflowException : SystemException {
+        public StackOverflowException();
+        public StackOverflowException(string message);
+        public StackOverflowException(string message, Exception innerException);
+    }
+    public sealed class STAThreadAttribute : Attribute {
+        public STAThreadAttribute();
+    }
+    public sealed class String : IComparable, IComparable<string>, IConvertible, IEnumerable, IEnumerable<char>, IEquatable<string> {
+        public static readonly string Empty;
+        public unsafe String(char* value);
+        public unsafe String(char* value, int startIndex, int length);
+        public String(char c, int count);
+        public String(char[] value);
+        public String(char[] value, int startIndex, int length);
+        [MethodImpl(InternalCall)]public unsafe String(sbyte* value);
+        public int Length { get; }
+        [System.Runtime.CompilerServices.IndexerName("Chars")]
+        public char this[int index] { get; }
+        public static int Compare(string strA, int indexA, string strB, int indexB, int length);
+        public static int Compare(string strA, int indexA, string strB, int indexB, int length, CultureInfo culture, CompareOptions options);
+        public static int Compare(string strA, int indexA, string strB, int indexB, int length, StringComparison comparisonType);
+        public static int Compare(string strA, string strB);
+        public static int Compare(string strA, string strB, bool ignoreCase);
+        public static int Compare(string strA, string strB, CultureInfo culture, CompareOptions options);
+        public static int Compare(string strA, string strB, StringComparison comparisonType);
+        public static int CompareOrdinal(string strA, int indexA, string strB, int indexB, int length);
+        public static int CompareOrdinal(string strA, string strB);
+        public int CompareTo(object value);
+        public int CompareTo(string strB);
+        public static string Concat(IEnumerable<string> values);
+        public static string Concat(object arg0);
+        public static string Concat(object arg0, object arg1);
+        public static string Concat(object arg0, object arg1, object arg2);
+        public static string Concat(params object[] args);
+        public static string Concat(string str0, string str1);
+        public static string Concat(string str0, string str1, string str2);
+        public static string Concat(string str0, string str1, string str2, string str3);
+        public static string Concat(params string[] values);
+        public static string Concat<T>(IEnumerable<T> values);
+        public bool Contains(string value);
+        public static string Copy(string str);
+        public void CopyTo(int sourceIndex, char[] destination, int destinationIndex, int count);
+        public bool EndsWith(string value);
+        public bool EndsWith(string value, StringComparison comparisonType);
+        public override bool Equals(object obj);
+        public bool Equals(string value);
+        public static bool Equals(string a, string b);
+        public static bool Equals(string a, string b, StringComparison comparisonType);
+        public bool Equals(string value, StringComparison comparisonType);
+        public static string Format(IFormatProvider provider, string format, object arg0);
+        public static string Format(IFormatProvider provider, string format, object arg0, object arg1);
+        public static string Format(IFormatProvider provider, string format, object arg0, object arg1, object arg2);
+        public static string Format(IFormatProvider provider, string format, params object[] args);
+        public static string Format(string format, object arg0);
+        public static string Format(string format, object arg0, object arg1);
+        public static string Format(string format, object arg0, object arg1, object arg2);
+        public static string Format(string format, params object[] args);
+        public override int GetHashCode();
+        public TypeCode GetTypeCode();
+        public int IndexOf(char value);
+        public int IndexOf(char value, int startIndex);
+        public int IndexOf(char value, int startIndex, int count);
+        public int IndexOf(string value);
+        public int IndexOf(string value, int startIndex);
+        public int IndexOf(string value, int startIndex, int count);
+        public int IndexOf(string value, int startIndex, int count, StringComparison comparisonType);
+        public int IndexOf(string value, int startIndex, StringComparison comparisonType);
+        public int IndexOf(string value, StringComparison comparisonType);
+        public int IndexOfAny(char[] anyOf);
+        public int IndexOfAny(char[] anyOf, int startIndex);
+        public int IndexOfAny(char[] anyOf, int startIndex, int count);
+        public string Insert(int startIndex, string value);
+        public static string Intern(string str);
+        public static string IsInterned(string str);
+        public static bool IsNullOrEmpty(string value);
+        public static bool IsNullOrWhiteSpace(string value);
+        public static string Join(string separator, IEnumerable<string> values);
+        public static string Join(string separator, params object[] values);
+        public static string Join(string separator, params string[] value);
+        public static string Join(string separator, string[] value, int startIndex, int count);
+        public static string Join<T>(string separator, IEnumerable<T> values);
+        public int LastIndexOf(char value);
+        public int LastIndexOf(char value, int startIndex);
+        public int LastIndexOf(char value, int startIndex, int count);
+        public int LastIndexOf(string value);
+        public int LastIndexOf(string value, int startIndex);
+        public int LastIndexOf(string value, int startIndex, int count);
+        public int LastIndexOf(string value, int startIndex, int count, StringComparison comparisonType);
+        public int LastIndexOf(string value, int startIndex, StringComparison comparisonType);
+        public int LastIndexOf(string value, StringComparison comparisonType);
+        public int LastIndexOfAny(char[] anyOf);
+        public int LastIndexOfAny(char[] anyOf, int startIndex);
+        public int LastIndexOfAny(char[] anyOf, int startIndex, int count);
+        public static bool operator ==(string a, string b);
+        public static bool operator !=(string a, string b);
+        public string PadLeft(int totalWidth);
+        public string PadLeft(int totalWidth, char paddingChar);
+        public string PadRight(int totalWidth);
+        public string PadRight(int totalWidth, char paddingChar);
+        public string Remove(int startIndex);
+        public string Remove(int startIndex, int count);
+        public string Replace(char oldChar, char newChar);
+        public string Replace(string oldValue, string newValue);
+        public string[] Split(params char[] separator);
+        public string[] Split(char[] separator, int count);
+        public string[] Split(char[] separator, int count, StringSplitOptions options);
+        public string[] Split(char[] separator, StringSplitOptions options);
+        public string[] Split(string[] separator, int count, StringSplitOptions options);
+        public string[] Split(string[] separator, StringSplitOptions options);
+        public bool StartsWith(string value);
+        public bool StartsWith(string value, StringComparison comparisonType);
+        public string Substring(int startIndex);
+        public string Substring(int startIndex, int length);
+        IEnumerator<char> System.Collections.Generic.IEnumerable<System.Char>.GetEnumerator();
+        IEnumerator System.Collections.IEnumerable.GetEnumerator();
+        int System.IComparable.CompareTo(object value);
+        TypeCode System.IConvertible.GetTypeCode();
+        bool System.IConvertible.ToBoolean(IFormatProvider provider);
+        byte System.IConvertible.ToByte(IFormatProvider provider);
+        char System.IConvertible.ToChar(IFormatProvider provider);
+        DateTime System.IConvertible.ToDateTime(IFormatProvider provider);
+        Decimal System.IConvertible.ToDecimal(IFormatProvider provider);
+        double System.IConvertible.ToDouble(IFormatProvider provider);
+        short System.IConvertible.ToInt16(IFormatProvider provider);
+        int System.IConvertible.ToInt32(IFormatProvider provider);
+        long System.IConvertible.ToInt64(IFormatProvider provider);
+        sbyte System.IConvertible.ToSByte(IFormatProvider provider);
+        float System.IConvertible.ToSingle(IFormatProvider provider);
+        string System.IConvertible.ToString(IFormatProvider provider);
+        object System.IConvertible.ToType(Type type, IFormatProvider provider);
+        ushort System.IConvertible.ToUInt16(IFormatProvider provider);
+        uint System.IConvertible.ToUInt32(IFormatProvider provider);
+        ulong System.IConvertible.ToUInt64(IFormatProvider provider);
+        public char[] ToCharArray();
+        public char[] ToCharArray(int startIndex, int length);
+        public string ToLower();
+        public string ToLower(CultureInfo culture);
+        public string ToLowerInvariant();
+        public override string ToString();
+        public string ToString(IFormatProvider provider);
+        public string ToUpper();
+        public string ToUpper(CultureInfo culture);
+        public string ToUpperInvariant();
+        public string Trim();
+        public string Trim(params char[] trimChars);
+        public string TrimEnd(params char[] trimChars);
+        public string TrimStart(params char[] trimChars);
+    }
+    public abstract class StringComparer : IComparer, IComparer<string>, IEqualityComparer, IEqualityComparer<string> {
+        protected StringComparer();
+        public static StringComparer CurrentCulture { get; }
+        public static StringComparer CurrentCultureIgnoreCase { get; }
+        public static StringComparer InvariantCulture { get; }
+        public static StringComparer InvariantCultureIgnoreCase { get; }
+        public static StringComparer Ordinal { get; }
+        public static StringComparer OrdinalIgnoreCase { get; }
+        public int Compare(object x, object y);
+        public abstract int Compare(string x, string y);
+        public static StringComparer Create(CultureInfo culture, bool ignoreCase);
+        public new bool Equals(object x, object y);
+        public abstract bool Equals(string x, string y);
+        public int GetHashCode(object obj);
+        public abstract int GetHashCode(string obj);
+        int System.Collections.IComparer.Compare(object x, object y);
+        bool System.Collections.IEqualityComparer.Equals(object x, object y);
+        int System.Collections.IEqualityComparer.GetHashCode(object obj);
+    }
+    public enum StringComparison {
+        CurrentCulture = 0,
+        CurrentCultureIgnoreCase = 1,
+        InvariantCulture = 2,
+        InvariantCultureIgnoreCase = 3,
+        Ordinal = 4,
+        OrdinalIgnoreCase = 5,
+    }
+    public static class StringNormalizationExtensions {
+        public static bool IsNormalized(this string value);
+        public static bool IsNormalized(this string value, NormalizationForm normalizationForm);
+        public static string Normalize(this string value);
+        public static string Normalize(this string value, NormalizationForm normalizationForm);
+    }
+    public enum StringSplitOptions {
+        None = 0,
+        RemoveEmptyEntries = 1,
+    }
+    public class SystemException : Exception {
+        public SystemException();
+        public SystemException(string message);
+        public SystemException(string message, Exception innerException);
+    }
+    public class ThreadStaticAttribute : Attribute {
+        public ThreadStaticAttribute();
+    }
+    public class TimeoutException : Exception {
+        public TimeoutException();
+        public TimeoutException(string message);
+        public TimeoutException(string message, Exception innerException);
+    }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable {
+        public const long TicksPerDay = (long)864000000000;
+        public const long TicksPerHour = (long)36000000000;
+        public const long TicksPerMillisecond = (long)10000;
+        public const long TicksPerMinute = (long)600000000;
+        public const long TicksPerSecond = (long)10000000;
+        public static readonly TimeSpan MaxValue;
+        public static readonly TimeSpan MinValue;
+        public static readonly TimeSpan Zero;
+        public TimeSpan(int hours, int minutes, int seconds);
+        public TimeSpan(int days, int hours, int minutes, int seconds);
+        public TimeSpan(int days, int hours, int minutes, int seconds, int milliseconds);
+        public TimeSpan(long ticks);
+        public int Days { get; }
+        public int Hours { get; }
+        public int Milliseconds { get; }
+        public int Minutes { get; }
+        public int Seconds { get; }
+        public long Ticks { get; }
+        public double TotalDays { get; }
+        public double TotalHours { get; }
+        public double TotalMilliseconds { get; }
+        public double TotalMinutes { get; }
+        public double TotalSeconds { get; }
+        public TimeSpan Add(TimeSpan ts);
+        public static int Compare(TimeSpan t1, TimeSpan t2);
+        public int CompareTo(object value);
+        public int CompareTo(TimeSpan value);
+        public TimeSpan Duration();
+        public override bool Equals(object value);
+        public bool Equals(TimeSpan obj);
+        public static bool Equals(TimeSpan t1, TimeSpan t2);
+        public static TimeSpan FromDays(double value);
+        public static TimeSpan FromHours(double value);
+        public static TimeSpan FromMilliseconds(double value);
+        public static TimeSpan FromMinutes(double value);
+        public static TimeSpan FromSeconds(double value);
+        public static TimeSpan FromTicks(long value);
+        public override int GetHashCode();
+        public TimeSpan Negate();
+        public static TimeSpan operator +(TimeSpan t1, TimeSpan t2);
+        public static bool operator ==(TimeSpan t1, TimeSpan t2);
+        public static bool operator >(TimeSpan t1, TimeSpan t2);
+        public static bool operator >=(TimeSpan t1, TimeSpan t2);
+        public static bool operator !=(TimeSpan t1, TimeSpan t2);
+        public static bool operator <(TimeSpan t1, TimeSpan t2);
+        public static bool operator <=(TimeSpan t1, TimeSpan t2);
+        public static TimeSpan operator -(TimeSpan t1, TimeSpan t2);
+        public static TimeSpan operator -(TimeSpan t);
+        public static TimeSpan operator +(TimeSpan t);
+        public static TimeSpan Parse(string s);
+        public static TimeSpan Parse(string input, IFormatProvider formatProvider);
+        public static TimeSpan ParseExact(string input, string format, IFormatProvider formatProvider);
+        public static TimeSpan ParseExact(string input, string format, IFormatProvider formatProvider, TimeSpanStyles styles);
+        public static TimeSpan ParseExact(string input, string[] formats, IFormatProvider formatProvider);
+        public static TimeSpan ParseExact(string input, string[] formats, IFormatProvider formatProvider, TimeSpanStyles styles);
+        public TimeSpan Subtract(TimeSpan ts);
+        int System.IComparable.CompareTo(object value);
+        public override string ToString();
+        public string ToString(string format);
+        public string ToString(string format, IFormatProvider formatProvider);
+        public static bool TryParse(string input, IFormatProvider formatProvider, out TimeSpan result);
+        public static bool TryParse(string s, out TimeSpan result);
+        public static bool TryParseExact(string input, string format, IFormatProvider formatProvider, TimeSpanStyles styles, out TimeSpan result);
+        public static bool TryParseExact(string input, string format, IFormatProvider formatProvider, out TimeSpan result);
+        public static bool TryParseExact(string input, string[] formats, IFormatProvider formatProvider, TimeSpanStyles styles, out TimeSpan result);
+        public static bool TryParseExact(string input, string[] formats, IFormatProvider formatProvider, out TimeSpan result);
+    }
+    public sealed class TimeZoneInfo : IEquatable<TimeZoneInfo> {
+        public TimeSpan BaseUtcOffset { get; }
+        public string DaylightName { get; }
+        public string DisplayName { get; }
+        public string Id { get; }
+        public static TimeZoneInfo Local { get; }
+        public string StandardName { get; }
+        public bool SupportsDaylightSavingTime { get; }
+        public static TimeZoneInfo Utc { get; }
+        public static DateTime ConvertTime(DateTime dateTime, TimeZoneInfo destinationTimeZone);
+        public static DateTime ConvertTime(DateTime dateTime, TimeZoneInfo sourceTimeZone, TimeZoneInfo destinationTimeZone);
+        public static DateTimeOffset ConvertTime(DateTimeOffset dateTimeOffset, TimeZoneInfo destinationTimeZone);
+        public override bool Equals(object obj);
+        public bool Equals(TimeZoneInfo other);
+        public static TimeZoneInfo FindSystemTimeZoneById(string id);
+        public TimeSpan[] GetAmbiguousTimeOffsets(DateTime dateTime);
+        public TimeSpan[] GetAmbiguousTimeOffsets(DateTimeOffset dateTimeOffset);
+        public override int GetHashCode();
+        public static ReadOnlyCollection<TimeZoneInfo> GetSystemTimeZones();
+        public TimeSpan GetUtcOffset(DateTime dateTime);
+        public TimeSpan GetUtcOffset(DateTimeOffset dateTimeOffset);
+        public bool IsAmbiguousTime(DateTime dateTime);
+        public bool IsAmbiguousTime(DateTimeOffset dateTimeOffset);
+        public bool IsDaylightSavingTime(DateTime dateTime);
+        public bool IsDaylightSavingTime(DateTimeOffset dateTimeOffset);
+        public bool IsInvalidTime(DateTime dateTime);
+        public override string ToString();
+        public sealed class AdjustmentRule : IEquatable<TimeZoneInfo.AdjustmentRule> {
+            public static TimeZoneInfo.AdjustmentRule CreateAdjustmentRule(DateTime dateStart, DateTime dateEnd, TimeSpan daylightDelta, TimeZoneInfo.TransitionTime daylightTransitionStart, TimeZoneInfo.TransitionTime daylightTransitionEnd);
+            public bool Equals(TimeZoneInfo.AdjustmentRule other);
+            public override int GetHashCode();
+        }
+        [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+        public struct TransitionTime : IEquatable<TimeZoneInfo.TransitionTime> {
+            public override bool Equals(object obj);
+            public bool Equals(TimeZoneInfo.TransitionTime other);
+            public override int GetHashCode();
+        }
+    }
+    public static class Tuple {
+        public static Tuple<T1, T2, T3, T4, T5, T6, T7, Tuple<T8>> Create<T1, T2, T3, T4, T5, T6, T7, T8>(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7, T8 item8);
+        public static Tuple<T1, T2, T3, T4, T5, T6, T7> Create<T1, T2, T3, T4, T5, T6, T7>(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7);
+        public static Tuple<T1, T2, T3, T4, T5, T6> Create<T1, T2, T3, T4, T5, T6>(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6);
+        public static Tuple<T1, T2, T3, T4, T5> Create<T1, T2, T3, T4, T5>(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5);
+        public static Tuple<T1, T2, T3, T4> Create<T1, T2, T3, T4>(T1 item1, T2 item2, T3 item3, T4 item4);
+        public static Tuple<T1, T2, T3> Create<T1, T2, T3>(T1 item1, T2 item2, T3 item3);
+        public static Tuple<T1, T2> Create<T1, T2>(T1 item1, T2 item2);
+        public static Tuple<T1> Create<T1>(T1 item1);
+    }
+    public class Tuple<T1> : IComparable, IStructuralComparable, IStructuralEquatable {
+        public Tuple(T1 item1);
+        public T1 Item1 { get; }
+        public override bool Equals(object obj);
+        public override int GetHashCode();
+        int System.Collections.IStructuralComparable.CompareTo(object other, IComparer comparer);
+        bool System.Collections.IStructuralEquatable.Equals(object other, IEqualityComparer comparer);
+        int System.Collections.IStructuralEquatable.GetHashCode(IEqualityComparer comparer);
+        int System.IComparable.CompareTo(object obj);
+        public override string ToString();
+    }
+    public class Tuple<T1, T2> : IComparable, IStructuralComparable, IStructuralEquatable {
+        public Tuple(T1 item1, T2 item2);
+        public T1 Item1 { get; }
+        public T2 Item2 { get; }
+        public override bool Equals(object obj);
+        public override int GetHashCode();
+        int System.Collections.IStructuralComparable.CompareTo(object other, IComparer comparer);
+        bool System.Collections.IStructuralEquatable.Equals(object other, IEqualityComparer comparer);
+        int System.Collections.IStructuralEquatable.GetHashCode(IEqualityComparer comparer);
+        int System.IComparable.CompareTo(object obj);
+        public override string ToString();
+    }
+    public class Tuple<T1, T2, T3> : IComparable, IStructuralComparable, IStructuralEquatable {
+        public Tuple(T1 item1, T2 item2, T3 item3);
+        public T1 Item1 { get; }
+        public T2 Item2 { get; }
+        public T3 Item3 { get; }
+        public override bool Equals(object obj);
+        public override int GetHashCode();
+        int System.Collections.IStructuralComparable.CompareTo(object other, IComparer comparer);
+        bool System.Collections.IStructuralEquatable.Equals(object other, IEqualityComparer comparer);
+        int System.Collections.IStructuralEquatable.GetHashCode(IEqualityComparer comparer);
+        int System.IComparable.CompareTo(object obj);
+        public override string ToString();
+    }
+    public class Tuple<T1, T2, T3, T4> : IComparable, IStructuralComparable, IStructuralEquatable {
+        public Tuple(T1 item1, T2 item2, T3 item3, T4 item4);
+        public T1 Item1 { get; }
+        public T2 Item2 { get; }
+        public T3 Item3 { get; }
+        public T4 Item4 { get; }
+        public override bool Equals(object obj);
+        public override int GetHashCode();
+        int System.Collections.IStructuralComparable.CompareTo(object other, IComparer comparer);
+        bool System.Collections.IStructuralEquatable.Equals(object other, IEqualityComparer comparer);
+        int System.Collections.IStructuralEquatable.GetHashCode(IEqualityComparer comparer);
+        int System.IComparable.CompareTo(object obj);
+        public override string ToString();
+    }
+    public class Tuple<T1, T2, T3, T4, T5> : IComparable, IStructuralComparable, IStructuralEquatable {
+        public Tuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5);
+        public T1 Item1 { get; }
+        public T2 Item2 { get; }
+        public T3 Item3 { get; }
+        public T4 Item4 { get; }
+        public T5 Item5 { get; }
+        public override bool Equals(object obj);
+        public override int GetHashCode();
+        int System.Collections.IStructuralComparable.CompareTo(object other, IComparer comparer);
+        bool System.Collections.IStructuralEquatable.Equals(object other, IEqualityComparer comparer);
+        int System.Collections.IStructuralEquatable.GetHashCode(IEqualityComparer comparer);
+        int System.IComparable.CompareTo(object obj);
+        public override string ToString();
+    }
+    public class Tuple<T1, T2, T3, T4, T5, T6> : IComparable, IStructuralComparable, IStructuralEquatable {
+        public Tuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6);
+        public T1 Item1 { get; }
+        public T2 Item2 { get; }
+        public T3 Item3 { get; }
+        public T4 Item4 { get; }
+        public T5 Item5 { get; }
+        public T6 Item6 { get; }
+        public override bool Equals(object obj);
+        public override int GetHashCode();
+        int System.Collections.IStructuralComparable.CompareTo(object other, IComparer comparer);
+        bool System.Collections.IStructuralEquatable.Equals(object other, IEqualityComparer comparer);
+        int System.Collections.IStructuralEquatable.GetHashCode(IEqualityComparer comparer);
+        int System.IComparable.CompareTo(object obj);
+        public override string ToString();
+    }
+    public class Tuple<T1, T2, T3, T4, T5, T6, T7> : IComparable, IStructuralComparable, IStructuralEquatable {
+        public Tuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7);
+        public T1 Item1 { get; }
+        public T2 Item2 { get; }
+        public T3 Item3 { get; }
+        public T4 Item4 { get; }
+        public T5 Item5 { get; }
+        public T6 Item6 { get; }
+        public T7 Item7 { get; }
+        public override bool Equals(object obj);
+        public override int GetHashCode();
+        int System.Collections.IStructuralComparable.CompareTo(object other, IComparer comparer);
+        bool System.Collections.IStructuralEquatable.Equals(object other, IEqualityComparer comparer);
+        int System.Collections.IStructuralEquatable.GetHashCode(IEqualityComparer comparer);
+        int System.IComparable.CompareTo(object obj);
+        public override string ToString();
+    }
+    public class Tuple<T1, T2, T3, T4, T5, T6, T7, TRest> : IComparable, IStructuralComparable, IStructuralEquatable {
+        public Tuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7, TRest rest);
+        public T1 Item1 { get; }
+        public T2 Item2 { get; }
+        public T3 Item3 { get; }
+        public T4 Item4 { get; }
+        public T5 Item5 { get; }
+        public T6 Item6 { get; }
+        public T7 Item7 { get; }
+        public TRest Rest { get; }
+        public override bool Equals(object obj);
+        public override int GetHashCode();
+        int System.Collections.IStructuralComparable.CompareTo(object other, IComparer comparer);
+        bool System.Collections.IStructuralEquatable.Equals(object other, IEqualityComparer comparer);
+        int System.Collections.IStructuralEquatable.GetHashCode(IEqualityComparer comparer);
+        int System.IComparable.CompareTo(object obj);
+        public override string ToString();
+    }
+    public abstract class Type {
+        public static readonly char Delimiter;
+        public static readonly object Missing;
+        public static readonly MemberFilter FilterNameIgnoreCase;
+        public static readonly Type[] EmptyTypes;
+        protected Type();
+        public abstract Assembly Assembly { get; }
+        public abstract string AssemblyQualifiedName { get; }
+        public TypeAttributes Attributes { get; }
+        public abstract Type BaseType { get; }
+        public virtual bool ContainsGenericParameters { get; }
+        public virtual MethodBase DeclaringMethod { get; }
+        public abstract Type DeclaringType { get; }
+        public static Binder DefaultBinder { get; }
+        public abstract string FullName { get; }
+        public virtual GenericParameterAttributes GenericParameterAttributes { get; }
+        public abstract int GenericParameterPosition { get; }
+        public abstract Type[] GenericTypeArguments { get; }
+        public abstract Guid GUID { get; }
+        public bool HasElementType { get; }
+        public bool IsAbstract { get; }
+        public bool IsAnsiClass { get; }
+        public virtual bool IsArray { get; }
+        public bool IsAutoClass { get; }
+        public bool IsAutoLayout { get; }
+        public virtual bool IsByRef { get; }
+        public bool IsClass { get; }
+        public bool IsCOMObject { get; }
+        public abstract bool IsConstructedGenericType { get; }
+        public bool IsEnum { get; }
+        public bool IsExplicitLayout { get; }
+        public abstract bool IsGenericParameter { get; }
+        public virtual bool IsGenericType { get; }
+        public virtual bool IsGenericTypeDefinition { get; }
+        public bool IsImport { get; }
+        public bool IsInterface { get; }
+        public bool IsLayoutSequential { get; }
+        public bool IsMarshalByRef { get; }
+        public bool IsNested { get; }
+        public bool IsNestedAssembly { get; }
+        public bool IsNestedFamANDAssem { get; }
+        public bool IsNestedFamily { get; }
+        public bool IsNestedFamORAssem { get; }
+        public bool IsNestedPrivate { get; }
+        public bool IsNestedPublic { get; }
+        public bool IsNotPublic { get; }
+        public virtual bool IsPointer { get; }
+        public bool IsPrimitive { get; }
+        public bool IsPublic { get; }
+        public bool IsSealed { get; }
+        public virtual bool IsSerializable { get; }
+        public bool IsSpecialName { get; }
+        public bool IsUnicodeClass { get; }
+        public bool IsValueType { get; }
+        public bool IsVisible { get; }
+        public override MemberTypes MemberType { get; }
+        public abstract new Module Module { get; }
+        public abstract string Name { get; }
+        public abstract string Namespace { get; }
+        public override Type ReflectedType { get; }
+        public virtual StructLayoutAttribute StructLayoutAttribute { get; }
+        public virtual RuntimeTypeHandle TypeHandle { get; }
+        public ConstructorInfo TypeInitializer { get; }
+        public abstract Type UnderlyingSystemType { get; }
+        public override bool Equals(object o);
+        public bool Equals(Type o);
+        public virtual Type[] FindInterfaces(TypeFilter filter, object filterCriteria);
+        public virtual MemberInfo[] FindMembers(MemberTypes memberType, BindingFlags bindingAttr, MemberFilter filter, object filterCriteria);
+        public abstract int GetArrayRank();
+        protected abstract TypeAttributes GetAttributeFlagsImpl();
+        public ConstructorInfo GetConstructor(BindingFlags bindingAttr, Binder binder, Type[] types, ParameterModifier[] modifiers);
+        public ConstructorInfo GetConstructor(Type[] types);
+        protected abstract ConstructorInfo GetConstructorImpl(BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers);
+        public ConstructorInfo[] GetConstructors();
+        public abstract ConstructorInfo[] GetConstructors(BindingFlags bindingAttr);
+        public virtual MemberInfo[] GetDefaultMembers();
+        public abstract Type GetElementType();
+        public virtual string GetEnumName(object value);
+        public virtual string[] GetEnumNames();
+        public virtual Type GetEnumUnderlyingType();
+        public virtual Array GetEnumValues();
+        public EventInfo GetEvent(string name);
+        public abstract EventInfo GetEvent(string name, BindingFlags bindingAttr);
+        public virtual EventInfo[] GetEvents();
+        public abstract EventInfo[] GetEvents(BindingFlags bindingAttr);
+        public FieldInfo GetField(string name);
+        public abstract FieldInfo GetField(string name, BindingFlags bindingAttr);
+        public FieldInfo[] GetFields();
+        public abstract FieldInfo[] GetFields(BindingFlags bindingAttr);
+        public virtual Type[] GetGenericArguments();
+        public virtual Type[] GetGenericParameterConstraints();
+        public abstract Type GetGenericTypeDefinition();
+        public override int GetHashCode();
+        public Type GetInterface(string name);
+        public abstract Type GetInterface(string name, bool ignoreCase);
+        public virtual InterfaceMapping GetInterfaceMap(Type interfaceType);
+        public abstract Type[] GetInterfaces();
+        public MemberInfo[] GetMember(string name);
+        public virtual MemberInfo[] GetMember(string name, BindingFlags bindingAttr);
+        public virtual MemberInfo[] GetMember(string name, MemberTypes type, BindingFlags bindingAttr);
+        public MemberInfo[] GetMembers();
+        public abstract MemberInfo[] GetMembers(BindingFlags bindingAttr);
+        public MethodInfo GetMethod(string name);
+        public MethodInfo GetMethod(string name, BindingFlags bindingAttr);
+        public MethodInfo GetMethod(string name, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers);
+        public MethodInfo GetMethod(string name, BindingFlags bindingAttr, Binder binder, Type[] types, ParameterModifier[] modifiers);
+        public MethodInfo GetMethod(string name, Type[] types);
+        public MethodInfo GetMethod(string name, Type[] types, ParameterModifier[] modifiers);
+        protected abstract MethodInfo GetMethodImpl(string name, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers);
+        public MethodInfo[] GetMethods();
+        public abstract MethodInfo[] GetMethods(BindingFlags bindingAttr);
+        public Type GetNestedType(string name);
+        public abstract Type GetNestedType(string name, BindingFlags bindingAttr);
+        public Type[] GetNestedTypes();
+        public abstract Type[] GetNestedTypes(BindingFlags bindingAttr);
+        public PropertyInfo[] GetProperties();
+        public abstract PropertyInfo[] GetProperties(BindingFlags bindingAttr);
+        public PropertyInfo GetProperty(string name);
+        public PropertyInfo GetProperty(string name, BindingFlags bindingAttr);
+        public PropertyInfo GetProperty(string name, BindingFlags bindingAttr, Binder binder, Type returnType, Type[] types, ParameterModifier[] modifiers);
+        public PropertyInfo GetProperty(string name, Type returnType);
+        public PropertyInfo GetProperty(string name, Type returnType, Type[] types);
+        public PropertyInfo GetProperty(string name, Type returnType, Type[] types, ParameterModifier[] modifiers);
+        public PropertyInfo GetProperty(string name, Type[] types);
+        protected abstract PropertyInfo GetPropertyImpl(string name, BindingFlags bindingAttr, Binder binder, Type returnType, Type[] types, ParameterModifier[] modifiers);
+        public static Type GetType(string typeName);
+        public static Type GetType(string typeName, bool throwOnError);
+        public static Type GetType(string typeName, bool throwOnError, bool ignoreCase);
+        public static TypeCode GetTypeCode(Type type);
+        public static Type GetTypeFromHandle(RuntimeTypeHandle handle);
+        public static RuntimeTypeHandle GetTypeHandle(object o);
+        protected abstract bool HasElementTypeImpl();
+        public object InvokeMember(string name, BindingFlags invokeAttr, Binder binder, object target, object[] args);
+        public abstract object InvokeMember(string name, BindingFlags invokeAttr, Binder binder, object target, object[] args, ParameterModifier[] modifiers, CultureInfo culture, string[] namedParameters);
+        protected abstract bool IsArrayImpl();
+        public virtual bool IsAssignableFrom(Type c);
+        protected abstract bool IsByRefImpl();
+        protected abstract bool IsCOMObjectImpl();
+        public virtual bool IsEnumDefined(object value);
+        public virtual bool IsEquivalentTo(Type other);
+        public virtual bool IsInstanceOfType(object o);
+        protected abstract bool IsPointerImpl();
+        protected abstract bool IsPrimitiveImpl();
+        public virtual bool IsSubclassOf(Type c);
+        protected virtual bool IsValueTypeImpl();
+        public abstract Type MakeArrayType();
+        public abstract Type MakeArrayType(int rank);
+        public abstract Type MakeByRefType();
+        public abstract Type MakeGenericType(params Type[] typeArguments);
+        public abstract Type MakePointerType();
+        public override string ToString();
+    }
+    public class TypeAccessException : TypeLoadException {
+        public TypeAccessException();
+        public TypeAccessException(string message);
+        public TypeAccessException(string message, Exception inner);
+    }
+    public enum TypeCode {
+        Boolean = 3,
+        Byte = 6,
+        Char = 4,
+        DateTime = 16,
+        DBNull = 2,
+        Decimal = 15,
+        Double = 14,
+        Empty = 0,
+        Int16 = 7,
+        Int32 = 9,
+        Int64 = 11,
+        Object = 1,
+        SByte = 5,
+        Single = 13,
+        String = 18,
+        UInt16 = 8,
+        UInt32 = 10,
+        UInt64 = 12,
+    }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct TypedReference {
+        public override bool Equals(object o);
+        public override int GetHashCode();
+    }
+    public sealed class TypeInitializationException : Exception {
+        public TypeInitializationException(string fullTypeName, Exception innerException);
+        public string TypeName { get; }
+    }
+    public class TypeLoadException : Exception {
+        public TypeLoadException();
+        public TypeLoadException(string message);
+        public TypeLoadException(string message, Exception inner);
+        public override string Message { get; }
+        public string TypeName { get; }
+    }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct UInt16 : IComparable, IComparable<ushort>, IConvertible, IEquatable<ushort>, IFormattable {
+        public const ushort MaxValue = (ushort)65535;
+        public const ushort MinValue = (ushort)0;
+        public int CompareTo(object value);
+        public int CompareTo(ushort value);
+        public override bool Equals(object obj);
+        public bool Equals(ushort obj);
+        public override int GetHashCode();
+        public TypeCode GetTypeCode();
+        public static ushort Parse(string s);
+        public static ushort Parse(string s, NumberStyles style);
+        public static ushort Parse(string s, NumberStyles style, IFormatProvider provider);
+        public static ushort Parse(string s, IFormatProvider provider);
+        int System.IComparable.CompareTo(object value);
+        TypeCode System.IConvertible.GetTypeCode();
+        bool System.IConvertible.ToBoolean(IFormatProvider provider);
+        byte System.IConvertible.ToByte(IFormatProvider provider);
+        char System.IConvertible.ToChar(IFormatProvider provider);
+        DateTime System.IConvertible.ToDateTime(IFormatProvider provider);
+        Decimal System.IConvertible.ToDecimal(IFormatProvider provider);
+        double System.IConvertible.ToDouble(IFormatProvider provider);
+        short System.IConvertible.ToInt16(IFormatProvider provider);
+        int System.IConvertible.ToInt32(IFormatProvider provider);
+        long System.IConvertible.ToInt64(IFormatProvider provider);
+        sbyte System.IConvertible.ToSByte(IFormatProvider provider);
+        float System.IConvertible.ToSingle(IFormatProvider provider);
+        object System.IConvertible.ToType(Type type, IFormatProvider provider);
+        ushort System.IConvertible.ToUInt16(IFormatProvider provider);
+        uint System.IConvertible.ToUInt32(IFormatProvider provider);
+        ulong System.IConvertible.ToUInt64(IFormatProvider provider);
+        public override string ToString();
+        public string ToString(IFormatProvider provider);
+        public string ToString(string format);
+        public string ToString(string format, IFormatProvider provider);
+        public static bool TryParse(string s, NumberStyles style, IFormatProvider provider, out ushort result);
+        public static bool TryParse(string s, out ushort result);
+    }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct UInt32 : IComparable, IComparable<uint>, IConvertible, IEquatable<uint>, IFormattable {
+        public const uint MaxValue = (uint)4294967295;
+        public const uint MinValue = (uint)0;
+        public int CompareTo(object value);
+        public int CompareTo(uint value);
+        public override bool Equals(object obj);
+        public bool Equals(uint obj);
+        public override int GetHashCode();
+        public TypeCode GetTypeCode();
+        public static uint Parse(string s);
+        public static uint Parse(string s, NumberStyles style);
+        public static uint Parse(string s, NumberStyles style, IFormatProvider provider);
+        public static uint Parse(string s, IFormatProvider provider);
+        int System.IComparable.CompareTo(object value);
+        TypeCode System.IConvertible.GetTypeCode();
+        bool System.IConvertible.ToBoolean(IFormatProvider provider);
+        byte System.IConvertible.ToByte(IFormatProvider provider);
+        char System.IConvertible.ToChar(IFormatProvider provider);
+        DateTime System.IConvertible.ToDateTime(IFormatProvider provider);
+        Decimal System.IConvertible.ToDecimal(IFormatProvider provider);
+        double System.IConvertible.ToDouble(IFormatProvider provider);
+        short System.IConvertible.ToInt16(IFormatProvider provider);
+        int System.IConvertible.ToInt32(IFormatProvider provider);
+        long System.IConvertible.ToInt64(IFormatProvider provider);
+        sbyte System.IConvertible.ToSByte(IFormatProvider provider);
+        float System.IConvertible.ToSingle(IFormatProvider provider);
+        object System.IConvertible.ToType(Type type, IFormatProvider provider);
+        ushort System.IConvertible.ToUInt16(IFormatProvider provider);
+        uint System.IConvertible.ToUInt32(IFormatProvider provider);
+        ulong System.IConvertible.ToUInt64(IFormatProvider provider);
+        public override string ToString();
+        public string ToString(IFormatProvider provider);
+        public string ToString(string format);
+        public string ToString(string format, IFormatProvider provider);
+        public static bool TryParse(string s, NumberStyles style, IFormatProvider provider, out uint result);
+        public static bool TryParse(string s, out uint result);
+    }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct UInt64 : IComparable, IComparable<ulong>, IConvertible, IEquatable<ulong>, IFormattable {
+        public const ulong MaxValue = (ulong)18446744073709551615;
+        public const ulong MinValue = (ulong)0;
+        public int CompareTo(object value);
+        public int CompareTo(ulong value);
+        public override bool Equals(object obj);
+        public bool Equals(ulong obj);
+        public override int GetHashCode();
+        public TypeCode GetTypeCode();
+        public static ulong Parse(string s);
+        public static ulong Parse(string s, NumberStyles style);
+        public static ulong Parse(string s, NumberStyles style, IFormatProvider provider);
+        public static ulong Parse(string s, IFormatProvider provider);
+        int System.IComparable.CompareTo(object value);
+        TypeCode System.IConvertible.GetTypeCode();
+        bool System.IConvertible.ToBoolean(IFormatProvider provider);
+        byte System.IConvertible.ToByte(IFormatProvider provider);
+        char System.IConvertible.ToChar(IFormatProvider provider);
+        DateTime System.IConvertible.ToDateTime(IFormatProvider provider);
+        Decimal System.IConvertible.ToDecimal(IFormatProvider provider);
+        double System.IConvertible.ToDouble(IFormatProvider provider);
+        short System.IConvertible.ToInt16(IFormatProvider provider);
+        int System.IConvertible.ToInt32(IFormatProvider provider);
+        long System.IConvertible.ToInt64(IFormatProvider provider);
+        sbyte System.IConvertible.ToSByte(IFormatProvider provider);
+        float System.IConvertible.ToSingle(IFormatProvider provider);
+        object System.IConvertible.ToType(Type type, IFormatProvider provider);
+        ushort System.IConvertible.ToUInt16(IFormatProvider provider);
+        uint System.IConvertible.ToUInt32(IFormatProvider provider);
+        ulong System.IConvertible.ToUInt64(IFormatProvider provider);
+        public override string ToString();
+        public string ToString(IFormatProvider provider);
+        public string ToString(string format);
+        public string ToString(string format, IFormatProvider provider);
+        public static bool TryParse(string s, NumberStyles style, IFormatProvider provider, out ulong result);
+        public static bool TryParse(string s, out ulong result);
+    }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct UIntPtr {
+        public static readonly UIntPtr Zero;
+        public UIntPtr(uint value);
+        public UIntPtr(ulong value);
+        public unsafe UIntPtr(void* value);
+        public static int Size { get; }
+        public static UIntPtr Add(UIntPtr pointer, int offset);
+        public override bool Equals(object obj);
+        public override int GetHashCode();
+        public static UIntPtr operator +(UIntPtr pointer, int offset);
+        public static bool operator ==(UIntPtr value1, UIntPtr value2);
+        public static explicit operator UIntPtr (uint value);
+        public static explicit operator UIntPtr (ulong value);
+        public static explicit operator uint (UIntPtr value);
+        public static explicit operator ulong (UIntPtr value);
+        public unsafe static explicit operator void* (UIntPtr value);
+        public unsafe static explicit operator UIntPtr (void* value);
+        public static bool operator !=(UIntPtr value1, UIntPtr value2);
+        public static UIntPtr operator -(UIntPtr pointer, int offset);
+        public static UIntPtr Subtract(UIntPtr pointer, int offset);
+        public unsafe void* ToPointer();
+        public override string ToString();
+        public uint ToUInt32();
+        public ulong ToUInt64();
+    }
+    public class UnauthorizedAccessException : Exception {
+        public UnauthorizedAccessException();
+        public UnauthorizedAccessException(string message);
+        public UnauthorizedAccessException(string message, Exception inner);
+    }
+    public class UnhandledExceptionEventArgs : EventArgs {
+        public UnhandledExceptionEventArgs(object exception, bool isTerminating);
+        public object ExceptionObject { get; }
+        public bool IsTerminating { get; }
+    }
+    public delegate void UnhandledExceptionEventHandler(object sender, UnhandledExceptionEventArgs e);
+    public class Uri {
+        public Uri(string uriString);
+        public Uri(string uriString, UriKind uriKind);
+        public Uri(Uri baseUri, string relativeUri);
+        public Uri(Uri baseUri, Uri relativeUri);
+        public string AbsolutePath { get; }
+        public string AbsoluteUri { get; }
+        public string Authority { get; }
+        public string DnsSafeHost { get; }
+        public string Fragment { get; }
+        public string Host { get; }
+        public UriHostNameType HostNameType { get; }
+        public string IdnHost { get; }
+        public bool IsAbsoluteUri { get; }
+        public bool IsDefaultPort { get; }
+        public bool IsFile { get; }
+        public bool IsLoopback { get; }
+        public bool IsUnc { get; }
+        public string LocalPath { get; }
+        public string OriginalString { get; }
+        public string PathAndQuery { get; }
+        public int Port { get; }
+        public string Query { get; }
+        public string Scheme { get; }
+        public string[] Segments { get; }
+        public bool UserEscaped { get; }
+        public string UserInfo { get; }
+        public static UriHostNameType CheckHostName(string name);
+        public static bool CheckSchemeName(string schemeName);
+        public static int Compare(Uri uri1, Uri uri2, UriComponents partsToCompare, UriFormat compareFormat, StringComparison comparisonType);
+        public override bool Equals(object comparand);
+        public static string EscapeDataString(string stringToEscape);
+        public static string EscapeUriString(string stringToEscape);
+        public string GetComponents(UriComponents components, UriFormat format);
+        public override int GetHashCode();
+        public bool IsBaseOf(Uri uri);
+        public bool IsWellFormedOriginalString();
+        public static bool IsWellFormedUriString(string uriString, UriKind uriKind);
+        public Uri MakeRelativeUri(Uri uri);
+        public static bool operator ==(Uri uri1, Uri uri2);
+        public static bool operator !=(Uri uri1, Uri uri2);
+        public override string ToString();
+        public static bool TryCreate(string uriString, UriKind uriKind, out Uri result);
+        public static bool TryCreate(Uri baseUri, string relativeUri, out Uri result);
+        public static bool TryCreate(Uri baseUri, Uri relativeUri, out Uri result);
+        public static string UnescapeDataString(string stringToUnescape);
+    }
+    public class UriBuilder {
+        public UriBuilder();
+        public UriBuilder(string uri);
+        public UriBuilder(string schemeName, string hostName);
+        public UriBuilder(string scheme, string host, int portNumber);
+        public UriBuilder(string scheme, string host, int port, string pathValue);
+        public UriBuilder(string scheme, string host, int port, string path, string extraValue);
+        public UriBuilder(Uri uri);
+        public string Fragment { get; set; }
+        public string Host { get; set; }
+        public string Password { get; set; }
+        public string Path { get; set; }
+        public int Port { get; set; }
+        public string Query { get; set; }
+        public string Scheme { get; set; }
+        public Uri Uri { get; }
+        public string UserName { get; set; }
+        public override bool Equals(object rparam);
+        public override int GetHashCode();
+        public override string ToString();
+    }
+    public enum UriComponents {
+        AbsoluteUri = 127,
+        Fragment = 64,
+        Host = 4,
+        HostAndPort = 132,
+        HttpRequestUrl = 61,
+        KeepDelimiter = 1073741824,
+        NormalizedHost = 256,
+        Path = 16,
+        PathAndQuery = 48,
+        Port = 8,
+        Query = 32,
+        Scheme = 1,
+        SchemeAndServer = 13,
+        SerializationInfoString = -2147483648,
+        StrongAuthority = 134,
+        StrongPort = 128,
+        UserInfo = 2,
+    }
+    public enum UriFormat {
+        SafeUnescaped = 3,
+        Unescaped = 2,
+        UriEscaped = 1,
+    }
+    public class UriFormatException : FormatException {
+        public UriFormatException();
+        public UriFormatException(string textString);
+        public UriFormatException(string textString, Exception e);
+    }
+    public enum UriHostNameType {
+        Basic = 1,
+        Dns = 2,
+        IPv4 = 3,
+        IPv6 = 4,
+        Unknown = 0,
+    }
+    public enum UriKind {
+        Absolute = 1,
+        Relative = 2,
+        RelativeOrAbsolute = 0,
+    }
+    public class UriTypeConverter : TypeConverter {
+        public UriTypeConverter();
+        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType);
+        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType);
+        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value);
+        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType);
+    }
+    public abstract class ValueType {
+        protected ValueType();
+        public override bool Equals(object obj);
+        public override int GetHashCode();
+        public override string ToString();
+    }
+    public sealed class Version : IComparable, IComparable<Version>, IEquatable<Version> {
+        public Version(int major, int minor);
+        public Version(int major, int minor, int build);
+        public Version(int major, int minor, int build, int revision);
+        public Version(string version);
+        public int Build { get; }
+        public int Major { get; }
+        public short MajorRevision { get; }
+        public int Minor { get; }
+        public short MinorRevision { get; }
+        public int Revision { get; }
+        public object Clone();
+        public int CompareTo(object version);
+        public int CompareTo(Version value);
+        public override bool Equals(object obj);
+        public bool Equals(Version obj);
+        public override int GetHashCode();
+        public static bool operator ==(Version v1, Version v2);
+        public static bool operator >(Version v1, Version v2);
+        public static bool operator >=(Version v1, Version v2);
+        public static bool operator !=(Version v1, Version v2);
+        public static bool operator <(Version v1, Version v2);
+        public static bool operator <=(Version v1, Version v2);
+        public static Version Parse(string input);
+        int System.IComparable.CompareTo(object version);
+        public override string ToString();
+        public string ToString(int fieldCount);
+        public static bool TryParse(string input, out Version result);
+    }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential, Size=1)]
+    public struct Void
+    public class WeakReference {
+        protected WeakReference();
+        public WeakReference(object target);
+        public WeakReference(object target, bool trackResurrection);
+        public virtual bool IsAlive { get; }
+        public virtual object Target { get; set; }
+        public virtual bool TrackResurrection { get; }
+        ~WeakReference();
+    }
+    public sealed class WeakReference<T> where T : class {
+        public WeakReference(T target);
+        public WeakReference(T target, bool trackResurrection);
+        ~WeakReference();
+        public void SetTarget(T target);
+        public bool TryGetTarget(out T target);
+    }
+}
```