Permalink
Fetching contributors…
Cannot retrieve contributors at this time
7654 lines (7651 sloc) 435 KB

.NET Standard 1.0

Overview | Next

 namespace System {
     public delegate void Action(); {
         public Action(object @object, IntPtr method);
         public virtual IAsyncResult BeginInvoke(AsyncCallback callback, object @object);
         public virtual void EndInvoke(IAsyncResult result);
         public virtual void Invoke();
     }
     public delegate void Action<in T>(T obj); {
         public Action(object @object, IntPtr method);
         public virtual IAsyncResult BeginInvoke(T obj, AsyncCallback callback, object @object);
         public virtual void EndInvoke(IAsyncResult result);
         public virtual void Invoke(T obj);
     }
     public delegate void Action<in T1, in T2>(T1 arg1, T2 arg2); {
         public Action(object @object, IntPtr method);
         public virtual IAsyncResult BeginInvoke(T1 arg1, T2 arg2, AsyncCallback callback, object @object);
         public virtual void EndInvoke(IAsyncResult result);
         public virtual void Invoke(T1 arg1, T2 arg2);
     }
     public delegate void Action<in T1, in T2, in T3>(T1 arg1, T2 arg2, T3 arg3); {
         public Action(object @object, IntPtr method);
         public virtual IAsyncResult BeginInvoke(T1 arg1, T2 arg2, T3 arg3, AsyncCallback callback, object @object);
         public virtual void EndInvoke(IAsyncResult result);
         public virtual void Invoke(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 Action(object @object, IntPtr method);
         public virtual IAsyncResult BeginInvoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4, AsyncCallback callback, object @object);
         public virtual void EndInvoke(IAsyncResult result);
         public virtual void Invoke(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 Action(object @object, IntPtr method);
         public virtual IAsyncResult BeginInvoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, AsyncCallback callback, object @object);
         public virtual void EndInvoke(IAsyncResult result);
         public virtual void Invoke(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 Action(object @object, IntPtr method);
         public virtual IAsyncResult BeginInvoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, AsyncCallback callback, object @object);
         public virtual void EndInvoke(IAsyncResult result);
         public virtual void Invoke(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 Action(object @object, IntPtr method);
         public virtual IAsyncResult BeginInvoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, AsyncCallback callback, object @object);
         public virtual void EndInvoke(IAsyncResult result);
         public virtual void Invoke(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 Action(object @object, IntPtr method);
         public virtual IAsyncResult BeginInvoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, AsyncCallback callback, object @object);
         public virtual void EndInvoke(IAsyncResult result);
         public virtual void Invoke(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 Action(object @object, IntPtr method);
         public virtual IAsyncResult BeginInvoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, AsyncCallback callback, object @object);
         public virtual void EndInvoke(IAsyncResult result);
         public virtual void Invoke(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 Action(object @object, IntPtr method);
         public virtual IAsyncResult BeginInvoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, AsyncCallback callback, object @object);
         public virtual void EndInvoke(IAsyncResult result);
         public virtual void Invoke(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 Action(object @object, IntPtr method);
         public virtual IAsyncResult BeginInvoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, AsyncCallback callback, object @object);
         public virtual void EndInvoke(IAsyncResult result);
         public virtual void Invoke(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 Action(object @object, IntPtr method);
         public virtual IAsyncResult BeginInvoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, AsyncCallback callback, object @object);
         public virtual void EndInvoke(IAsyncResult result);
         public virtual void Invoke(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 Action(object @object, IntPtr method);
         public virtual IAsyncResult BeginInvoke(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, AsyncCallback callback, object @object);
         public virtual void EndInvoke(IAsyncResult result);
         public virtual void Invoke(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 Action(object @object, IntPtr method);
         public virtual IAsyncResult BeginInvoke(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, AsyncCallback callback, object @object);
         public virtual void EndInvoke(IAsyncResult result);
         public virtual void Invoke(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 Action(object @object, IntPtr method);
         public virtual IAsyncResult BeginInvoke(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, AsyncCallback callback, object @object);
         public virtual void EndInvoke(IAsyncResult result);
         public virtual void Invoke(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 Action(object @object, IntPtr method);
         public virtual IAsyncResult BeginInvoke(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, AsyncCallback callback, object @object);
         public virtual void EndInvoke(IAsyncResult result);
         public virtual void Invoke(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 T CreateInstance<T>();
         public static object CreateInstance(Type type);
         public static object CreateInstance(Type type, params object[] args);
     }
     public class AggregateException : Exception {
         public AggregateException();
         public AggregateException(params Exception[] innerExceptions);
         public AggregateException(IEnumerable<Exception> innerExceptions);
         public AggregateException(string message);
         public AggregateException(string message, Exception innerException);
         public AggregateException(string message, params Exception[] innerExceptions);
         public AggregateException(string message, IEnumerable<Exception> innerExceptions);
         public ReadOnlyCollection<Exception> InnerExceptions { get; }
         public AggregateException Flatten();
         public override Exception GetBaseException();
         public void Handle(Func<Exception, bool> predicate);
         public override string ToString();
     }
     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 int Length { get; }
         public int Rank { get; }
         public static int BinarySearch<T>(T[] array, T value);
         public static int BinarySearch<T>(T[] array, T value, IComparer<T> 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(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 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, params int[] lengths);
         public static Array CreateInstance(Type elementType, int[] lengths, int[] lowerBounds);
         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, Predicate<T> match);
         public static int FindIndex<T>(T[] array, int startIndex, Predicate<T> match);
         public static int FindIndex<T>(T[] array, int startIndex, int count, Predicate<T> match);
         public static T FindLast<T>(T[] array, Predicate<T> match);
         public static int FindLastIndex<T>(T[] array, Predicate<T> match);
         public static int FindLastIndex<T>(T[] array, int startIndex, Predicate<T> match);
         public static int FindLastIndex<T>(T[] array, int startIndex, int count, Predicate<T> match);
         public IEnumerator GetEnumerator();
         public int GetLength(int dimension);
         public int GetLowerBound(int dimension);
         public int GetUpperBound(int dimension);
         public object GetValue(params int[] indices);
         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 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 void Initialize();
         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 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 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, params int[] indices);
         public static void Sort<T>(T[] array);
         public static void Sort<T>(T[] array, IComparer<T> comparer);
         public static void Sort<T>(T[] array, int index, int length);
         public static void Sort<T>(T[] array, Comparison<T> comparison);
         public static void Sort<T>(T[] array, int index, int length, IComparer<T> comparer);
         public static void Sort(Array array);
         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 bool TrueForAll<T>(T[] array, Predicate<T> match);
     }
     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; }
         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);
     }
     public class ArrayTypeMismatchException : Exception {
         public ArrayTypeMismatchException();
         public ArrayTypeMismatchException(string message);
         public ArrayTypeMismatchException(string message, Exception innerException);
     }
     public delegate void AsyncCallback(IAsyncResult ar); {
         public AsyncCallback(object @object, IntPtr method);
         public virtual IAsyncResult BeginInvoke(IAsyncResult ar, AsyncCallback callback, object @object);
         public virtual void EndInvoke(IAsyncResult result);
         public virtual void Invoke(IAsyncResult ar);
     }
     public abstract class Attribute {
         protected Attribute();
         public override bool Equals(object obj);
         public override int GetHashCode();
     }
     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);
     }
     public struct Boolean : IComparable, IComparable<bool>, IEquatable<bool> {
         public static readonly string FalseString;
         public static readonly string TrueString;
         public int CompareTo(bool value);
         public bool Equals(bool obj);
         public override bool Equals(object obj);
         public override int GetHashCode();
         public static bool Parse(string value);
         public override string ToString();
         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 static void SetByte(Array array, int index, byte value);
     }
     public struct Byte : IComparable, IComparable<byte>, IEquatable<byte>, IFormattable {
         public const byte MaxValue = (byte)255;
         public const byte MinValue = (byte)0;
         public int CompareTo(byte value);
         public bool Equals(byte obj);
         public override bool Equals(object obj);
         public override int GetHashCode();
         public static byte Parse(string s);
         public static byte Parse(string s, IFormatProvider provider);
         public static byte Parse(string s, NumberStyles style);
         public static byte Parse(string s, NumberStyles style, 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 struct Char : IComparable, IComparable<char>, IEquatable<char> {
         public const char MaxValue = '\uFFFF';
         public const char MinValue = '\0';
         public int CompareTo(char 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 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 ToLower(char c);
         public static char ToLowerInvariant(char c);
         public override string ToString();
         public static string ToString(char c);
         public static char ToUpper(char c);
         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 Comparison(object @object, IntPtr method);
         public virtual IAsyncResult BeginInvoke(T x, T y, AsyncCallback callback, object @object);
         public virtual int EndInvoke(IAsyncResult result);
         public virtual int Invoke(T x, T y);
     }
     public static class Convert {
         public static object ChangeType(object value, Type conversionType);
         public static object ChangeType(object value, Type conversionType, IFormatProvider provider);
         public static byte[] FromBase64CharArray(char[] inArray, int offset, int length);
         public static byte[] FromBase64String(string s);
         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(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(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(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(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(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(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 struct DateTime : IComparable, IComparable<DateTime>, 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, 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, int millisecond);
         public DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, 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 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 string[] GetDateTimeFormats();
         public string[] GetDateTimeFormats(char format);
         public string[] GetDateTimeFormats(char format, IFormatProvider provider);
         public string[] GetDateTimeFormats(IFormatProvider provider);
         public override int GetHashCode();
         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);
         public long ToBinary();
         public long ToFileTime();
         public long ToFileTimeUtc();
         public DateTime ToLocalTime();
         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,
     }
     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, 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 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);
         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 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 struct Decimal : IComparable, IComparable<decimal>, 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 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 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 char (decimal value);
         public static explicit operator double (decimal value);
         public static explicit operator short (decimal value);
         public static explicit operator int (decimal value);
         public static explicit operator long (decimal value);
         public static explicit operator sbyte (decimal value);
         public static explicit operator float (decimal value);
         public static explicit operator ushort (decimal value);
         public static explicit operator uint (decimal value);
         public static explicit operator ulong (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, IFormatProvider provider);
         public static decimal Parse(string s, NumberStyles style);
         public static decimal Parse(string s, NumberStyles style, IFormatProvider provider);
         public static decimal Remainder(decimal d1, decimal d2);
         public static decimal Subtract(decimal d1, decimal d2);
         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 {
         public object Target { get; }
         public static Delegate Combine(Delegate a, Delegate b);
         public static Delegate Combine(params Delegate[] delegates);
         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);
     }
     public class DivideByZeroException : ArithmeticException {
         public DivideByZeroException();
         public DivideByZeroException(string message);
         public DivideByZeroException(string message, Exception innerException);
     }
     public struct Double : IComparable, IComparable<double>, 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 bool Equals(double obj);
         public override bool Equals(object obj);
         public override int GetHashCode();
         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, IFormatProvider provider);
         public static double Parse(string s, NumberStyles style);
         public static double Parse(string s, NumberStyles style, 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 abstract class Enum : ValueType, IComparable, 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 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);
         public static object ToObject(Type enumType, object value);
         public override string ToString();
         public string ToString(string format);
         public static bool TryParse<TEnum>(string value, out TEnum result) where TEnum : struct;
         public static bool TryParse<TEnum>(string value, bool ignoreCase, out TEnum result) where TEnum : struct;
     }
     public static class Environment {
         public static int CurrentManagedThreadId { get; }
         public static bool HasShutdownStarted { get; }
         public static string NewLine { get; }
         public static int ProcessorCount { get; }
         public static int TickCount { get; }
         public static void FailFast(string message);
         public static void FailFast(string message, Exception exception);
     }
     public class EventArgs {
         public static readonly EventArgs Empty;
         public EventArgs();
     }
     public delegate void EventHandler(object sender, EventArgs e); {
         public EventHandler(object @object, IntPtr method);
         public virtual IAsyncResult BeginInvoke(object sender, EventArgs e, AsyncCallback callback, object @object);
         public virtual void EndInvoke(IAsyncResult result);
         public virtual void Invoke(object sender, EventArgs e);
     }
     public delegate void EventHandler<TEventArgs>(object sender, TEventArgs e); {
         public EventHandler(object @object, IntPtr method);
         public virtual IAsyncResult BeginInvoke(object sender, TEventArgs e, AsyncCallback callback, object @object);
         public virtual void EndInvoke(IAsyncResult result);
         public virtual void Invoke(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 class FlagsAttribute : Attribute {
         public FlagsAttribute();
     }
     public class FormatException : Exception {
         public FormatException();
         public FormatException(string message);
         public FormatException(string message, Exception innerException);
     }
     public delegate TResult Func<out TResult>(); {
         public Func(object @object, IntPtr method);
         public virtual IAsyncResult BeginInvoke(AsyncCallback callback, object @object);
         public virtual TResult EndInvoke(IAsyncResult result);
         public virtual TResult Invoke();
     }
     public delegate TResult Func<in T, out TResult>(T arg); {
         public Func(object @object, IntPtr method);
         public virtual IAsyncResult BeginInvoke(T arg, AsyncCallback callback, object @object);
         public virtual TResult EndInvoke(IAsyncResult result);
         public virtual TResult Invoke(T arg);
     }
     public delegate TResult Func<in T1, in T2, out TResult>(T1 arg1, T2 arg2); {
         public Func(object @object, IntPtr method);
         public virtual IAsyncResult BeginInvoke(T1 arg1, T2 arg2, AsyncCallback callback, object @object);
         public virtual TResult EndInvoke(IAsyncResult result);
         public virtual TResult Invoke(T1 arg1, T2 arg2);
     }
     public delegate TResult Func<in T1, in T2, in T3, out TResult>(T1 arg1, T2 arg2, T3 arg3); {
         public Func(object @object, IntPtr method);
         public virtual IAsyncResult BeginInvoke(T1 arg1, T2 arg2, T3 arg3, AsyncCallback callback, object @object);
         public virtual TResult EndInvoke(IAsyncResult result);
         public virtual TResult Invoke(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 Func(object @object, IntPtr method);
         public virtual IAsyncResult BeginInvoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4, AsyncCallback callback, object @object);
         public virtual TResult EndInvoke(IAsyncResult result);
         public virtual TResult Invoke(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 Func(object @object, IntPtr method);
         public virtual IAsyncResult BeginInvoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, AsyncCallback callback, object @object);
         public virtual TResult EndInvoke(IAsyncResult result);
         public virtual TResult Invoke(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 Func(object @object, IntPtr method);
         public virtual IAsyncResult BeginInvoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, AsyncCallback callback, object @object);
         public virtual TResult EndInvoke(IAsyncResult result);
         public virtual TResult Invoke(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 Func(object @object, IntPtr method);
         public virtual IAsyncResult BeginInvoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, AsyncCallback callback, object @object);
         public virtual TResult EndInvoke(IAsyncResult result);
         public virtual TResult Invoke(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 Func(object @object, IntPtr method);
         public virtual IAsyncResult BeginInvoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, AsyncCallback callback, object @object);
         public virtual TResult EndInvoke(IAsyncResult result);
         public virtual TResult Invoke(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 Func(object @object, IntPtr method);
         public virtual IAsyncResult BeginInvoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, AsyncCallback callback, object @object);
         public virtual TResult EndInvoke(IAsyncResult result);
         public virtual TResult Invoke(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 Func(object @object, IntPtr method);
         public virtual IAsyncResult BeginInvoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, AsyncCallback callback, object @object);
         public virtual TResult EndInvoke(IAsyncResult result);
         public virtual TResult Invoke(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 Func(object @object, IntPtr method);
         public virtual IAsyncResult BeginInvoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, AsyncCallback callback, object @object);
         public virtual TResult EndInvoke(IAsyncResult result);
         public virtual TResult Invoke(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 Func(object @object, IntPtr method);
         public virtual IAsyncResult BeginInvoke(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, AsyncCallback callback, object @object);
         public virtual TResult EndInvoke(IAsyncResult result);
         public virtual TResult Invoke(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 Func(object @object, IntPtr method);
         public virtual IAsyncResult BeginInvoke(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, AsyncCallback callback, object @object);
         public virtual TResult EndInvoke(IAsyncResult result);
         public virtual TResult Invoke(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 Func(object @object, IntPtr method);
         public virtual IAsyncResult BeginInvoke(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, AsyncCallback callback, object @object);
         public virtual TResult EndInvoke(IAsyncResult result);
         public virtual TResult Invoke(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 Func(object @object, IntPtr method);
         public virtual IAsyncResult BeginInvoke(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, AsyncCallback callback, object @object);
         public virtual TResult EndInvoke(IAsyncResult result);
         public virtual TResult Invoke(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 Func(object @object, IntPtr method);
         public virtual IAsyncResult BeginInvoke(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, AsyncCallback callback, object @object);
         public virtual TResult EndInvoke(IAsyncResult result);
         public virtual TResult Invoke(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 int CollectionCount(int generation);
         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,
     }
     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 int CompareTo(Guid 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);
         public byte[] ToByteArray();
         public override string ToString();
         public string ToString(string format);
         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 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 struct Int16 : IComparable, IComparable<short>, IEquatable<short>, IFormattable {
         public const short MaxValue = (short)32767;
         public const short MinValue = (short)-32768;
         public int CompareTo(short value);
         public bool Equals(short obj);
         public override bool Equals(object obj);
         public override int GetHashCode();
         public static short Parse(string s);
         public static short Parse(string s, IFormatProvider provider);
         public static short Parse(string s, NumberStyles style);
         public static short Parse(string s, NumberStyles style, 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 short result);
         public static bool TryParse(string s, NumberStyles style, IFormatProvider provider, out short result);
     }
     public struct Int32 : IComparable, IComparable<int>, IEquatable<int>, IFormattable {
         public const int MaxValue = 2147483647;
         public const int MinValue = -2147483648;
         public int CompareTo(int value);
         public bool Equals(int obj);
         public override bool Equals(object obj);
         public override int GetHashCode();
         public static int Parse(string s);
         public static int Parse(string s, IFormatProvider provider);
         public static int Parse(string s, NumberStyles style);
         public static int Parse(string s, NumberStyles style, 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 int result);
         public static bool TryParse(string s, NumberStyles style, IFormatProvider provider, out int result);
     }
     public struct Int64 : IComparable, IComparable<long>, IEquatable<long>, IFormattable {
         public const long MaxValue = (long)9223372036854775807;
         public const long MinValue = (long)-9223372036854775808;
         public int CompareTo(long value);
         public bool Equals(long obj);
         public override bool Equals(object obj);
         public override int GetHashCode();
         public static long Parse(string s);
         public static long Parse(string s, IFormatProvider provider);
         public static long Parse(string s, NumberStyles style);
         public static long Parse(string s, NumberStyles style, 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 long result);
         public static bool TryParse(string s, NumberStyles style, IFormatProvider provider, out long result);
     }
     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 static explicit operator int (IntPtr value);
         public static explicit operator long (IntPtr value);
         public unsafe static explicit operator void* (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 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 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 enum MidpointRounding {
         AwayFromZero = 1,
         ToEven = 0,
     }
     public class MissingMemberException : MemberAccessException {
         public MissingMemberException();
         public MissingMemberException(string message);
         public MissingMemberException(string message, Exception inner);
         public override string Message { get; }
     }
     public sealed class MTAThreadAttribute : Attribute {
         public MTAThreadAttribute();
     }
     public abstract class MulticastDelegate : Delegate {
         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);
     }
     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;
         public static bool Equals<T>(Nullable<T> n1, Nullable<T> n2) where T : struct;
         public static Type GetUnderlyingType(Type nullableType);
     }
     public struct Nullable<T> where T : struct {
         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 class OperationCanceledException : Exception {
         public OperationCanceledException();
         public OperationCanceledException(CancellationToken token);
         public OperationCanceledException(string message);
         public OperationCanceledException(string message, CancellationToken token);
         public OperationCanceledException(string message, Exception innerException);
         public OperationCanceledException(string message, Exception innerException, 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 class PlatformNotSupportedException : NotSupportedException {
         public PlatformNotSupportedException();
         public PlatformNotSupportedException(string message);
         public PlatformNotSupportedException(string message, Exception inner);
     }
     public delegate bool Predicate<in T>(T obj); {
         public Predicate(object @object, IntPtr method);
         public virtual IAsyncResult BeginInvoke(T obj, AsyncCallback callback, object @object);
         public virtual bool EndInvoke(IAsyncResult result);
         public virtual bool Invoke(T obj);
     }
     public class Progress<T> : IProgress<T> {
         public Progress();
         public Progress(Action<T> handler);
         protected virtual void OnReport(T value);
         public event EventHandler<T> ProgressChanged;
     }
     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 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);
     }
     public struct RuntimeMethodHandle {
         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);
     }
     public struct RuntimeTypeHandle {
         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);
     }
     public struct SByte : IComparable, IComparable<sbyte>, IEquatable<sbyte>, IFormattable {
         public const sbyte MaxValue = (sbyte)127;
         public const sbyte MinValue = (sbyte)-128;
         public int CompareTo(sbyte value);
         public override bool Equals(object obj);
         public bool Equals(sbyte obj);
         public override int GetHashCode();
         public static sbyte Parse(string s);
         public static sbyte Parse(string s, IFormatProvider provider);
         public static sbyte Parse(string s, NumberStyles style);
         public static sbyte Parse(string s, NumberStyles style, 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);
     }
     public struct Single : IComparable, IComparable<float>, 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(float value);
         public override bool Equals(object obj);
         public bool Equals(float obj);
         public override int GetHashCode();
         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, IFormatProvider provider);
         public static float Parse(string s, NumberStyles style);
         public static float Parse(string s, NumberStyles style, 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 STAThreadAttribute : Attribute {
         public STAThreadAttribute();
     }
     public sealed class String : IComparable, IComparable<string>, IEnumerable, 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);
         public char this[int index] { get; }
         public int Length { 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, StringComparison comparisonType);
         public static int Compare(string strA, string strB);
         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(string strB);
         public static string Concat<T>(IEnumerable<T> values);
         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 bool Contains(string value);
         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, params object[] args);
         public static string Format(string format, params object[] args);
         public override int GetHashCode();
         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 bool IsNullOrEmpty(string value);
         public static bool IsNullOrWhiteSpace(string value);
         public static string Join<T>(string separator, IEnumerable<T> values);
         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 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);
         public char[] ToCharArray();
         public char[] ToCharArray(int startIndex, int length);
         public string ToLower();
         public string ToLowerInvariant();
         public override string ToString();
         public string ToUpper();
         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 Ordinal { get; }
         public static StringComparer OrdinalIgnoreCase { get; }
         public abstract int Compare(string x, string y);
         public abstract bool Equals(string x, string y);
         public abstract int GetHashCode(string obj);
     }
     public enum StringComparison {
         CurrentCulture = 0,
         CurrentCultureIgnoreCase = 1,
         Ordinal = 4,
         OrdinalIgnoreCase = 5,
     }
     public enum StringSplitOptions {
         None = 0,
         RemoveEmptyEntries = 1,
     }
     public class ThreadStaticAttribute : Attribute {
         public ThreadStaticAttribute();
     }
     public class TimeoutException : Exception {
         public TimeoutException();
         public TimeoutException(string message);
         public TimeoutException(string message, Exception innerException);
     }
     public struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable {
         public static readonly TimeSpan MaxValue;
         public static readonly TimeSpan MinValue;
         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 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(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);
         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, 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[] formats, IFormatProvider formatProvider, out TimeSpan result);
         public static bool TryParseExact(string input, string[] formats, IFormatProvider formatProvider, TimeSpanStyles styles, out TimeSpan result);
     }
     public sealed class TimeZoneInfo : IEquatable<TimeZoneInfo> {
         public TimeSpan BaseUtcOffset { get; }
         public string DaylightName { get; }
         public string DisplayName { 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 DateTimeOffset ConvertTime(DateTimeOffset dateTimeOffset, TimeZoneInfo destinationTimeZone);
         public bool Equals(TimeZoneInfo other);
         public TimeSpan[] GetAmbiguousTimeOffsets(DateTime dateTime);
         public TimeSpan[] GetAmbiguousTimeOffsets(DateTimeOffset dateTimeOffset);
         public override int GetHashCode();
         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 static class Tuple {
         public static Tuple<T1> Create<T1>(T1 item1);
         public static Tuple<T1, T2> Create<T1, T2>(T1 item1, T2 item2);
         public static Tuple<T1, T2, T3> Create<T1, T2, T3>(T1 item1, T2 item2, T3 item3);
         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, 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, 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, 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, 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 class Tuple<T1> : IComparable, IStructuralComparable, IStructuralEquatable {
         public Tuple(T1 item1);
         public T1 Item1 { get; }
         public override bool Equals(object obj);
         public override int GetHashCode();
         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();
         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();
         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();
         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();
         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();
         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();
         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();
         public override string ToString();
     }
     public abstract class Type {
         public static readonly object Missing;
         public abstract string AssemblyQualifiedName { get; }
         public abstract Type DeclaringType { get; }
         public abstract string FullName { get; }
         public abstract int GenericParameterPosition { get; }
         public abstract Type[] GenericTypeArguments { get; }
         public bool HasElementType { get; }
         public bool IsArray { get; }
         public bool IsByRef { get; }
         public abstract bool IsConstructedGenericType { get; }
         public abstract bool IsGenericParameter { get; }
         public bool IsNested { get; }
         public bool IsPointer { get; }
         public abstract string Name { get; }
         public abstract string Namespace { get; }
         public virtual RuntimeTypeHandle TypeHandle { get; }
         public override bool Equals(object o);
         public bool Equals(Type o);
         public abstract int GetArrayRank();
         public abstract Type GetElementType();
         public abstract Type GetGenericTypeDefinition();
         public override int GetHashCode();
         public static Type GetType(string typeName);
         public static Type GetType(string typeName, bool throwOnError);
         public static Type GetTypeFromHandle(RuntimeTypeHandle handle);
         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 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; }
     }
     public struct UInt16 : IComparable, IComparable<ushort>, IEquatable<ushort>, IFormattable {
         public const ushort MaxValue = (ushort)65535;
         public const ushort MinValue = (ushort)0;
         public int CompareTo(ushort value);
         public override bool Equals(object obj);
         public bool Equals(ushort obj);
         public override int GetHashCode();
         public static ushort Parse(string s);
         public static ushort Parse(string s, IFormatProvider provider);
         public static ushort Parse(string s, NumberStyles style);
         public static ushort Parse(string s, NumberStyles style, 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);
     }
     public struct UInt32 : IComparable, IComparable<uint>, IEquatable<uint>, IFormattable {
         public const uint MaxValue = (uint)4294967295;
         public const uint MinValue = (uint)0;
         public int CompareTo(uint value);
         public override bool Equals(object obj);
         public bool Equals(uint obj);
         public override int GetHashCode();
         public static uint Parse(string s);
         public static uint Parse(string s, IFormatProvider provider);
         public static uint Parse(string s, NumberStyles style);
         public static uint Parse(string s, NumberStyles style, 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);
     }
     public struct UInt64 : IComparable, IComparable<ulong>, IEquatable<ulong>, IFormattable {
         public const ulong MaxValue = (ulong)18446744073709551615;
         public const ulong MinValue = (ulong)0;
         public int CompareTo(ulong value);
         public override bool Equals(object obj);
         public bool Equals(ulong obj);
         public override int GetHashCode();
         public static ulong Parse(string s);
         public static ulong Parse(string s, IFormatProvider provider);
         public static ulong Parse(string s, NumberStyles style);
         public static ulong Parse(string s, NumberStyles style, 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);
     }
     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 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 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 enum UriHostNameType {
         Basic = 1,
         Dns = 2,
         IPv4 = 3,
         IPv6 = 4,
         Unknown = 0,
     }
     public enum UriKind {
         Absolute = 1,
         Relative = 2,
         RelativeOrAbsolute = 0,
     }
     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 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);
         public override string ToString();
         public string ToString(int fieldCount);
         public static bool TryParse(string input, out Version result);
     }
     public struct Void
     public class 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);
         public void SetTarget(T target);
         public bool TryGetTarget(out T target);
     }
 }
 namespace System.CodeDom.Compiler {
     public sealed class GeneratedCodeAttribute : Attribute {
         public GeneratedCodeAttribute(string tool, string version);
         public string Tool { get; }
         public string Version { get; }
     }
 }
 namespace System.Collections {
     public sealed class BitArray : ICollection, IEnumerable {
         public BitArray(BitArray bits);
         public BitArray(bool[] values);
         public BitArray(byte[] bytes);
         public BitArray(int length);
         public BitArray(int length, bool defaultValue);
         public BitArray(int[] values);
         public bool this[int index] { get; set; }
         public int Length { get; set; }
         public BitArray And(BitArray value);
         public bool Get(int index);
         public IEnumerator GetEnumerator();
         public BitArray Not();
         public BitArray Or(BitArray value);
         public void Set(int index, bool value);
         public void SetAll(bool value);
         public BitArray Xor(BitArray value);
     }
     public struct DictionaryEntry {
         public DictionaryEntry(object key, object value);
         public object Key { get; set; }
         public object Value { get; set; }
     }
     public interface ICollection : IEnumerable {
         int Count { get; }
         bool IsSynchronized { get; }
         object SyncRoot { get; }
         void CopyTo(Array array, int index);
     }
     public interface IComparer {
         int Compare(object x, object y);
     }
     public interface IDictionary : ICollection, IEnumerable {
         bool IsFixedSize { get; }
         bool IsReadOnly { get; }
         object this[object key] { get; set; }
         ICollection Keys { get; }
         ICollection Values { get; }
         void Add(object key, object value);
         void Clear();
         bool Contains(object key);
         new IDictionaryEnumerator GetEnumerator();
         void Remove(object key);
     }
     public interface IDictionaryEnumerator : IEnumerator {
         DictionaryEntry Entry { get; }
         object Key { get; }
         object Value { get; }
     }
     public interface IEnumerable {
         IEnumerator GetEnumerator();
     }
     public interface IEnumerator {
         object Current { get; }
         bool MoveNext();
         void Reset();
     }
     public interface IEqualityComparer {
         bool Equals(object x, object y);
         int GetHashCode(object obj);
     }
     public interface IList : ICollection, IEnumerable {
         bool IsFixedSize { get; }
         bool IsReadOnly { get; }
         object this[int index] { get; set; }
         int Add(object value);
         void Clear();
         bool Contains(object value);
         int IndexOf(object value);
         void Insert(int index, object value);
         void Remove(object value);
         void RemoveAt(int index);
     }
     public interface IStructuralComparable {
         int CompareTo(object other, IComparer comparer);
     }
     public interface IStructuralEquatable {
         bool Equals(object other, IEqualityComparer comparer);
         int GetHashCode(IEqualityComparer comparer);
     }
     public static class StructuralComparisons {
         public static IComparer StructuralComparer { get; }
         public static IEqualityComparer StructuralEqualityComparer { get; }
     }
 }
 namespace System.Collections.Generic {
     public abstract class Comparer<T> : IComparer, IComparer<T> {
         protected Comparer();
         public static Comparer<T> Default { get; }
         public abstract int Compare(T x, T y);
         public static Comparer<T> Create(Comparison<T> comparison);
     }
     public class Dictionary<TKey, TValue> : ICollection, ICollection<KeyValuePair<TKey, TValue>>, IDictionary, IDictionary<TKey, TValue>, IEnumerable, IEnumerable<KeyValuePair<TKey, TValue>>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IReadOnlyDictionary<TKey, TValue> {
         public struct Enumerator : IDictionaryEnumerator, IDisposable, IEnumerator, IEnumerator<KeyValuePair<TKey, TValue>> {
             public KeyValuePair<TKey, TValue> Current { get; }
             public void Dispose();
             public bool MoveNext();
         }
         public sealed class KeyCollection : ICollection, ICollection<TKey>, IEnumerable, IEnumerable<TKey> {
             public struct Enumerator : IDisposable, IEnumerator, IEnumerator<TKey> {
                 public TKey Current { get; }
                 public void Dispose();
                 public bool MoveNext();
             }
             public KeyCollection(Dictionary<TKey, TValue> dictionary);
             public int Count { get; }
             public void CopyTo(TKey[] array, int index);
             public Dictionary<TKey, TValue>.KeyCollection.Enumerator GetEnumerator();
         }
         public sealed class ValueCollection : ICollection, ICollection<TValue>, IEnumerable, IEnumerable<TValue> {
             public struct Enumerator : IDisposable, IEnumerator, IEnumerator<TValue> {
                 public TValue Current { get; }
                 public void Dispose();
                 public bool MoveNext();
             }
             public ValueCollection(Dictionary<TKey, TValue> dictionary);
             public int Count { get; }
             public void CopyTo(TValue[] array, int index);
             public Dictionary<TKey, TValue>.ValueCollection.Enumerator GetEnumerator();
         }
         public Dictionary();
         public Dictionary(IDictionary<TKey, TValue> dictionary);
         public Dictionary(IDictionary<TKey, TValue> dictionary, IEqualityComparer<TKey> comparer);
         public Dictionary(IEqualityComparer<TKey> comparer);
         public Dictionary(int capacity);
         public Dictionary(int capacity, IEqualityComparer<TKey> comparer);
         public IEqualityComparer<TKey> Comparer { get; }
         public int Count { get; }
         public TValue this[TKey key] { get; set; }
         public Dictionary<TKey, TValue>.KeyCollection Keys { get; }
         public Dictionary<TKey, TValue>.ValueCollection Values { get; }
         public void Add(TKey key, TValue value);
         public void Clear();
         public bool ContainsKey(TKey key);
         public bool ContainsValue(TValue value);
         public Dictionary<TKey, TValue>.Enumerator GetEnumerator();
         public bool Remove(TKey key);
         public bool TryGetValue(TKey key, out TValue value);
     }
     public abstract class EqualityComparer<T> : IEqualityComparer, IEqualityComparer<T> {
         protected EqualityComparer();
         public static EqualityComparer<T> Default { get; }
         public abstract bool Equals(T x, T y);
         public abstract int GetHashCode(T obj);
     }
     public class HashSet<T> : ICollection<T>, IEnumerable, IEnumerable<T>, ISet<T> {
         public struct Enumerator : IDisposable, IEnumerator, IEnumerator<T> {
             public T Current { get; }
             public void Dispose();
             public bool MoveNext();
         }
         public HashSet();
         public HashSet(IEnumerable<T> collection);
         public HashSet(IEnumerable<T> collection, IEqualityComparer<T> comparer);
         public HashSet(IEqualityComparer<T> comparer);
         public IEqualityComparer<T> Comparer { get; }
         public int Count { get; }
         public bool Add(T item);
         public void Clear();
         public bool Contains(T item);
         public void CopyTo(T[] array);
         public void CopyTo(T[] array, int arrayIndex);
         public void CopyTo(T[] array, int arrayIndex, int count);
         public void ExceptWith(IEnumerable<T> other);
         public HashSet<T>.Enumerator GetEnumerator();
         public void IntersectWith(IEnumerable<T> other);
         public bool IsProperSubsetOf(IEnumerable<T> other);
         public bool IsProperSupersetOf(IEnumerable<T> other);
         public bool IsSubsetOf(IEnumerable<T> other);
         public bool IsSupersetOf(IEnumerable<T> other);
         public bool Overlaps(IEnumerable<T> other);
         public bool Remove(T item);
         public int RemoveWhere(Predicate<T> match);
         public bool SetEquals(IEnumerable<T> other);
         public void SymmetricExceptWith(IEnumerable<T> other);
         public void TrimExcess();
         public void UnionWith(IEnumerable<T> other);
     }
     public interface ICollection<T> : IEnumerable, IEnumerable<T> {
         int Count { get; }
         bool IsReadOnly { get; }
         void Add(T item);
         void Clear();
         bool Contains(T item);
         void CopyTo(T[] array, int arrayIndex);
         bool Remove(T item);
     }
     public interface IComparer<in T> {
         int Compare(T x, T y);
     }
     public interface IDictionary<TKey, TValue> : ICollection<KeyValuePair<TKey, TValue>>, IEnumerable, IEnumerable<KeyValuePair<TKey, TValue>> {
         TValue this[TKey key] { get; set; }
         ICollection<TKey> Keys { get; }
         ICollection<TValue> Values { get; }
         void Add(TKey key, TValue value);
         bool ContainsKey(TKey key);
         bool Remove(TKey key);
         bool TryGetValue(TKey key, out TValue value);
     }
     public interface IEnumerable<out T> : IEnumerable {
         new IEnumerator<T> GetEnumerator();
     }
     public interface IEnumerator<out T> : IDisposable, IEnumerator {
         new T Current { get; }
     }
     public interface IEqualityComparer<in T> {
         bool Equals(T x, T y);
         int GetHashCode(T obj);
     }
     public interface IList<T> : ICollection<T>, IEnumerable, IEnumerable<T> {
         T this[int index] { get; set; }
         int IndexOf(T item);
         void Insert(int index, T item);
         void RemoveAt(int index);
     }
     public interface IReadOnlyCollection<out T> : IEnumerable, IEnumerable<T> {
         int Count { get; }
     }
     public interface IReadOnlyDictionary<TKey, TValue> : IEnumerable, IEnumerable<KeyValuePair<TKey, TValue>>, IReadOnlyCollection<KeyValuePair<TKey, TValue>> {
         TValue this[TKey key] { get; }
         IEnumerable<TKey> Keys { get; }
         IEnumerable<TValue> Values { get; }
         bool ContainsKey(TKey key);
         bool TryGetValue(TKey key, out TValue value);
     }
     public interface IReadOnlyList<out T> : IEnumerable, IEnumerable<T>, IReadOnlyCollection<T> {
         T this[int index] { get; }
     }
     public interface ISet<T> : ICollection<T>, IEnumerable, IEnumerable<T> {
         new bool Add(T item);
         void ExceptWith(IEnumerable<T> other);
         void IntersectWith(IEnumerable<T> other);
         bool IsProperSubsetOf(IEnumerable<T> other);
         bool IsProperSupersetOf(IEnumerable<T> other);
         bool IsSubsetOf(IEnumerable<T> other);
         bool IsSupersetOf(IEnumerable<T> other);
         bool Overlaps(IEnumerable<T> other);
         bool SetEquals(IEnumerable<T> other);
         void SymmetricExceptWith(IEnumerable<T> other);
         void UnionWith(IEnumerable<T> other);
     }
     public class KeyNotFoundException : Exception {
         public KeyNotFoundException();
         public KeyNotFoundException(string message);
         public KeyNotFoundException(string message, Exception innerException);
     }
     public struct KeyValuePair<TKey, TValue> {
         public KeyValuePair(TKey key, TValue value);
         public TKey Key { get; }
         public TValue Value { get; }
         public override string ToString();
     }
     public class LinkedList<T> : ICollection, ICollection<T>, IEnumerable, IEnumerable<T> {
         public struct Enumerator : IDisposable, IEnumerator, IEnumerator<T> {
             public T Current { get; }
             public void Dispose();
             public bool MoveNext();
         }
         public LinkedList();
         public LinkedList(IEnumerable<T> collection);
         public int Count { get; }
         public LinkedListNode<T> First { get; }
         public LinkedListNode<T> Last { get; }
         public LinkedListNode<T> AddAfter(LinkedListNode<T> node, T value);
         public void AddAfter(LinkedListNode<T> node, LinkedListNode<T> newNode);
         public LinkedListNode<T> AddBefore(LinkedListNode<T> node, T value);
         public void AddBefore(LinkedListNode<T> node, LinkedListNode<T> newNode);
         public void AddFirst(LinkedListNode<T> node);
         public LinkedListNode<T> AddFirst(T value);
         public void AddLast(LinkedListNode<T> node);
         public LinkedListNode<T> AddLast(T value);
         public void Clear();
         public bool Contains(T value);
         public void CopyTo(T[] array, int index);
         public LinkedListNode<T> Find(T value);
         public LinkedListNode<T> FindLast(T value);
         public LinkedList<T>.Enumerator GetEnumerator();
         public void Remove(LinkedListNode<T> node);
         public bool Remove(T value);
         public void RemoveFirst();
         public void RemoveLast();
     }
     public sealed class LinkedListNode<T> {
         public LinkedListNode(T value);
         public LinkedList<T> List { get; }
         public LinkedListNode<T> Next { get; }
         public LinkedListNode<T> Previous { get; }
         public T Value { get; set; }
     }
     public class List<T> : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IList, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T> {
         public struct Enumerator : IDisposable, IEnumerator, IEnumerator<T> {
             public T Current { get; }
             public void Dispose();
             public bool MoveNext();
         }
         public List();
         public List(IEnumerable<T> collection);
         public List(int capacity);
         public int Capacity { get; set; }
         public int Count { get; }
         public T this[int index] { get; set; }
         public void Add(T item);
         public void AddRange(IEnumerable<T> collection);
         public int BinarySearch(int index, int count, T item, IComparer<T> comparer);
         public int BinarySearch(T item);
         public int BinarySearch(T item, IComparer<T> comparer);
         public void Clear();
         public bool Contains(T item);
         public void CopyTo(int index, T[] array, int arrayIndex, int count);
         public void CopyTo(T[] array);
         public void CopyTo(T[] array, int arrayIndex);
         public bool Exists(Predicate<T> match);
         public T Find(Predicate<T> match);
         public List<T> FindAll(Predicate<T> match);
         public int FindIndex(int startIndex, int count, Predicate<T> match);
         public int FindIndex(int startIndex, Predicate<T> match);
         public int FindIndex(Predicate<T> match);
         public T FindLast(Predicate<T> match);
         public int FindLastIndex(int startIndex, int count, Predicate<T> match);
         public int FindLastIndex(int startIndex, Predicate<T> match);
         public int FindLastIndex(Predicate<T> match);
         public List<T>.Enumerator GetEnumerator();
         public List<T> GetRange(int index, int count);
         public int IndexOf(T item);
         public int IndexOf(T item, int index);
         public int IndexOf(T item, int index, int count);
         public void Insert(int index, T item);
         public void InsertRange(int index, IEnumerable<T> collection);
         public int LastIndexOf(T item);
         public int LastIndexOf(T item, int index);
         public int LastIndexOf(T item, int index, int count);
         public bool Remove(T item);
         public int RemoveAll(Predicate<T> match);
         public void RemoveAt(int index);
         public void RemoveRange(int index, int count);
         public void Reverse();
         public void Reverse(int index, int count);
         public void Sort();
         public void Sort(Comparison<T> comparison);
         public void Sort(IComparer<T> comparer);
         public void Sort(int index, int count, IComparer<T> comparer);
         public T[] ToArray();
         public void TrimExcess();
         public bool TrueForAll(Predicate<T> match);
     }
     public class Queue<T> : ICollection, IEnumerable, IEnumerable<T> {
         public struct Enumerator : IDisposable, IEnumerator, IEnumerator<T> {
             public T Current { get; }
             public void Dispose();
             public bool MoveNext();
         }
         public Queue();
         public Queue(IEnumerable<T> collection);
         public Queue(int capacity);
         public int Count { get; }
         public void Clear();
         public bool Contains(T item);
         public void CopyTo(T[] array, int arrayIndex);
         public T Dequeue();
         public void Enqueue(T item);
         public Queue<T>.Enumerator GetEnumerator();
         public T Peek();
         public T[] ToArray();
         public void TrimExcess();
     }
     public class SortedDictionary<TKey, TValue> : ICollection, ICollection<KeyValuePair<TKey, TValue>>, IDictionary, IDictionary<TKey, TValue>, IEnumerable, IEnumerable<KeyValuePair<TKey, TValue>> {
         public struct Enumerator : IDictionaryEnumerator, IDisposable, IEnumerator, IEnumerator<KeyValuePair<TKey, TValue>> {
             public KeyValuePair<TKey, TValue> Current { get; }
             public void Dispose();
             public bool MoveNext();
         }
         public sealed class KeyCollection : ICollection, ICollection<TKey>, IEnumerable, IEnumerable<TKey> {
             public struct Enumerator : IDisposable, IEnumerator, IEnumerator<TKey> {
                 public TKey Current { get; }
                 public void Dispose();
                 public bool MoveNext();
             }
             public KeyCollection(SortedDictionary<TKey, TValue> dictionary);
             public int Count { get; }
             public void CopyTo(TKey[] array, int index);
             public SortedDictionary<TKey, TValue>.KeyCollection.Enumerator GetEnumerator();
         }
         public sealed class ValueCollection : ICollection, ICollection<TValue>, IEnumerable, IEnumerable<TValue> {
             public struct Enumerator : IDisposable, IEnumerator, IEnumerator<TValue> {
                 public TValue Current { get; }
                 public void Dispose();
                 public bool MoveNext();
             }
             public ValueCollection(SortedDictionary<TKey, TValue> dictionary);
             public int Count { get; }
             public void CopyTo(TValue[] array, int index);
             public SortedDictionary<TKey, TValue>.ValueCollection.Enumerator GetEnumerator();
         }
         public SortedDictionary();
         public SortedDictionary(IComparer<TKey> comparer);
         public SortedDictionary(IDictionary<TKey, TValue> dictionary);
         public SortedDictionary(IDictionary<TKey, TValue> dictionary, IComparer<TKey> comparer);
         public IComparer<TKey> Comparer { get; }
         public int Count { get; }
         public TValue this[TKey key] { get; set; }
         public SortedDictionary<TKey, TValue>.KeyCollection Keys { get; }
         public SortedDictionary<TKey, TValue>.ValueCollection Values { get; }
         public void Add(TKey key, TValue value);
         public void Clear();
         public bool ContainsKey(TKey key);
         public bool ContainsValue(TValue value);
         public void CopyTo(KeyValuePair<TKey, TValue>[] array, int index);
         public SortedDictionary<TKey, TValue>.Enumerator GetEnumerator();
         public bool Remove(TKey key);
         public bool TryGetValue(TKey key, out TValue value);
     }
     public class SortedSet<T> : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, ISet<T> {
         public struct Enumerator : IDisposable, IEnumerator, IEnumerator<T> {
             public T Current { get; }
             public void Dispose();
             public bool MoveNext();
         }
         public SortedSet();
         public SortedSet(IComparer<T> comparer);
         public SortedSet(IEnumerable<T> collection);
         public SortedSet(IEnumerable<T> collection, IComparer<T> comparer);
         public IComparer<T> Comparer { get; }
         public int Count { get; }
         public T Max { get; }
         public T Min { get; }
         public bool Add(T item);
         public virtual void Clear();
         public virtual bool Contains(T item);
         public void CopyTo(T[] array);
         public void CopyTo(T[] array, int index);
         public void CopyTo(T[] array, int index, int count);
         public void ExceptWith(IEnumerable<T> other);
         public SortedSet<T>.Enumerator GetEnumerator();
         public virtual SortedSet<T> GetViewBetween(T lowerValue, T upperValue);
         public virtual void IntersectWith(IEnumerable<T> other);
         public bool IsProperSubsetOf(IEnumerable<T> other);
         public bool IsProperSupersetOf(IEnumerable<T> other);
         public bool IsSubsetOf(IEnumerable<T> other);
         public bool IsSupersetOf(IEnumerable<T> other);
         public bool Overlaps(IEnumerable<T> other);
         public bool Remove(T item);
         public int RemoveWhere(Predicate<T> match);
         public IEnumerable<T> Reverse();
         public bool SetEquals(IEnumerable<T> other);
         public void SymmetricExceptWith(IEnumerable<T> other);
         public void UnionWith(IEnumerable<T> other);
     }
     public class Stack<T> : ICollection, IEnumerable, IEnumerable<T> {
         public struct Enumerator : IDisposable, IEnumerator, IEnumerator<T> {
             public T Current { get; }
             public void Dispose();
             public bool MoveNext();
         }
         public Stack();
         public Stack(IEnumerable<T> collection);
         public Stack(int capacity);
         public int Count { get; }
         public void Clear();
         public bool Contains(T item);
         public void CopyTo(T[] array, int arrayIndex);
         public Stack<T>.Enumerator GetEnumerator();
         public T Peek();
         public T Pop();
         public void Push(T item);
         public T[] ToArray();
         public void TrimExcess();
     }
 }
 namespace System.Collections.ObjectModel {
     public class Collection<T> : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IList, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T> {
         public Collection();
         public Collection(IList<T> list);
         public int Count { get; }
         protected IList<T> Items { get; }
         public T this[int index] { get; set; }
         public void Add(T item);
         public void Clear();
         protected virtual void ClearItems();
         public bool Contains(T item);
         public void CopyTo(T[] array, int index);
         public IEnumerator<T> GetEnumerator();
         public int IndexOf(T item);
         public void Insert(int index, T item);
         protected virtual void InsertItem(int index, T item);
         public bool Remove(T item);
         public void RemoveAt(int index);
         protected virtual void RemoveItem(int index);
         protected virtual void SetItem(int index, T item);
     }
     public abstract class KeyedCollection<TKey, TItem> : Collection<TItem> {
         protected KeyedCollection();
         protected KeyedCollection(IEqualityComparer<TKey> comparer);
         protected KeyedCollection(IEqualityComparer<TKey> comparer, int dictionaryCreationThreshold);
         public IEqualityComparer<TKey> Comparer { get; }
         protected IDictionary<TKey, TItem> Dictionary { get; }
         public TItem this[TKey key] { get; }
         protected void ChangeItemKey(TItem item, TKey newKey);
         protected override void ClearItems();
         public bool Contains(TKey key);
         protected abstract TKey GetKeyForItem(TItem item);
         protected override void InsertItem(int index, TItem item);
         public bool Remove(TKey key);
         protected override void RemoveItem(int index);
         protected override void SetItem(int index, TItem item);
     }
     public class ObservableCollection<T> : Collection<T>, INotifyCollectionChanged, INotifyPropertyChanged {
         public ObservableCollection();
         public ObservableCollection(IEnumerable<T> collection);
         protected IDisposable BlockReentrancy();
         protected void CheckReentrancy();
         protected override void ClearItems();
         protected override void InsertItem(int index, T item);
         public void Move(int oldIndex, int newIndex);
         protected virtual void MoveItem(int oldIndex, int newIndex);
         protected virtual void OnCollectionChanged(NotifyCollectionChangedEventArgs e);
         protected virtual void OnPropertyChanged(PropertyChangedEventArgs e);
         protected override void RemoveItem(int index);
         protected override void SetItem(int index, T item);
         public virtual event NotifyCollectionChangedEventHandler CollectionChanged;
         protected virtual event PropertyChangedEventHandler PropertyChanged;
     }
     public class ReadOnlyCollection<T> : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IList, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T> {
         public ReadOnlyCollection(IList<T> list);
         public int Count { get; }
         protected IList<T> Items { get; }
         public T this[int index] { get; }
         public bool Contains(T value);
         public void CopyTo(T[] array, int index);
         public IEnumerator<T> GetEnumerator();
         public int IndexOf(T value);
     }
     public class ReadOnlyDictionary<TKey, TValue> : ICollection, ICollection<KeyValuePair<TKey, TValue>>, IDictionary, IDictionary<TKey, TValue>, IEnumerable, IEnumerable<KeyValuePair<TKey, TValue>>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IReadOnlyDictionary<TKey, TValue> {
         public sealed class KeyCollection : ICollection, ICollection<TKey>, IEnumerable, IEnumerable<TKey> {
             public int Count { get; }
             public void CopyTo(TKey[] array, int arrayIndex);
             public IEnumerator<TKey> GetEnumerator();
         }
         public sealed class ValueCollection : ICollection, ICollection<TValue>, IEnumerable, IEnumerable<TValue> {
             public int Count { get; }
             public void CopyTo(TValue[] array, int arrayIndex);
             public IEnumerator<TValue> GetEnumerator();
         }
         public ReadOnlyDictionary(IDictionary<TKey, TValue> dictionary);
         public int Count { get; }
         protected IDictionary<TKey, TValue> Dictionary { get; }
         public TValue this[TKey key] { get; }
         public ReadOnlyDictionary<TKey, TValue>.KeyCollection Keys { get; }
         public ReadOnlyDictionary<TKey, TValue>.ValueCollection Values { get; }
         public bool ContainsKey(TKey key);
         public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator();
         public bool TryGetValue(TKey key, out TValue value);
     }
     public class ReadOnlyObservableCollection<T> : ReadOnlyCollection<T>, INotifyCollectionChanged, INotifyPropertyChanged {
         public ReadOnlyObservableCollection(ObservableCollection<T> list);
         protected virtual void OnCollectionChanged(NotifyCollectionChangedEventArgs args);
         protected virtual void OnPropertyChanged(PropertyChangedEventArgs args);
         protected virtual event NotifyCollectionChangedEventHandler CollectionChanged;
         protected virtual event PropertyChangedEventHandler PropertyChanged;
     }
 }
 namespace System.Collections.Specialized {
     public interface INotifyCollectionChanged {
         event NotifyCollectionChangedEventHandler CollectionChanged;
     }
     public enum NotifyCollectionChangedAction {
         Add = 0,
         Move = 3,
         Remove = 1,
         Replace = 2,
         Reset = 4,
     }
     public class NotifyCollectionChangedEventArgs : EventArgs {
         public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action);
         public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, IList changedItems);
         public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, IList newItems, IList oldItems);
         public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, IList newItems, IList oldItems, int startingIndex);
         public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, IList changedItems, int startingIndex);
         public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, IList changedItems, int index, int oldIndex);
         public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, object changedItem);
         public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, object changedItem, int index);
         public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, object changedItem, int index, int oldIndex);
         public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, object newItem, object oldItem);
         public NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction action, object newItem, object oldItem, int index);
         public NotifyCollectionChangedAction Action { get; }
         public IList NewItems { get; }
         public int NewStartingIndex { get; }
         public IList OldItems { get; }
         public int OldStartingIndex { get; }
     }
     public delegate void NotifyCollectionChangedEventHandler(object sender, NotifyCollectionChangedEventArgs e); {
         public NotifyCollectionChangedEventHandler(object @object, IntPtr method);
         public virtual IAsyncResult BeginInvoke(object sender, NotifyCollectionChangedEventArgs e, AsyncCallback callback, object @object);
         public virtual void EndInvoke(IAsyncResult result);
         public virtual void Invoke(object sender, NotifyCollectionChangedEventArgs e);
     }
 }
 namespace System.ComponentModel {
     public class DataErrorsChangedEventArgs : EventArgs {
         public DataErrorsChangedEventArgs(string propertyName);
         public virtual string PropertyName { get; }
     }
     public class DefaultValueAttribute : Attribute {
         public DefaultValueAttribute(bool value);
         public DefaultValueAttribute(byte value);
         public DefaultValueAttribute(char value);
         public DefaultValueAttribute(double value);
         public DefaultValueAttribute(short value);
         public DefaultValueAttribute(int value);
         public DefaultValueAttribute(long value);
         public DefaultValueAttribute(object value);
         public DefaultValueAttribute(float value);
         public DefaultValueAttribute(string value);
         public DefaultValueAttribute(Type type, string value);
         public virtual object Value { get; }
         public override bool Equals(object obj);
         public override int GetHashCode();
     }
     public sealed class EditorBrowsableAttribute : Attribute {
         public EditorBrowsableAttribute(EditorBrowsableState state);
         public EditorBrowsableState State { get; }
         public override bool Equals(object obj);
         public override int GetHashCode();
     }
     public enum EditorBrowsableState {
         Advanced = 2,
         Always = 0,
         Never = 1,
     }
     public interface INotifyDataErrorInfo {
         bool HasErrors { get; }
         IEnumerable GetErrors(string propertyName);
         event EventHandler<DataErrorsChangedEventArgs> ErrorsChanged;
     }
     public interface INotifyPropertyChanged {
         event PropertyChangedEventHandler PropertyChanged;
     }
     public class PropertyChangedEventArgs : EventArgs {
         public PropertyChangedEventArgs(string propertyName);
         public string PropertyName { get; }
     }
     public delegate void PropertyChangedEventHandler(object sender, PropertyChangedEventArgs e); {
         public PropertyChangedEventHandler(object @object, IntPtr method);
         public virtual IAsyncResult BeginInvoke(object sender, PropertyChangedEventArgs e, AsyncCallback callback, object @object);
         public virtual void EndInvoke(IAsyncResult result);
         public virtual void Invoke(object sender, PropertyChangedEventArgs e);
     }
 }
 namespace System.Diagnostics {
     public sealed class ConditionalAttribute : Attribute {
         public ConditionalAttribute(string conditionString);
         public string ConditionString { get; }
     }
     public static class Debug {
         public static void Assert(bool condition);
         public static void Assert(bool condition, string message);
         public static void WriteLine(object value);
         public static void WriteLine(string message);
         public static void WriteLine(string format, params object[] args);
         public static void WriteLineIf(bool condition, string message);
     }
     public sealed class DebuggableAttribute : Attribute {
         public enum DebuggingModes {
             Default = 1,
             DisableOptimizations = 256,
             EnableEditAndContinue = 4,
             IgnoreSymbolStoreSequencePoints = 2,
             None = 0,
         }
         public DebuggableAttribute(DebuggableAttribute.DebuggingModes modes);
     }
     public static class Debugger {
         public static bool IsAttached { get; }
         public static void Break();
         public static bool Launch();
     }
     public sealed class DebuggerBrowsableAttribute : Attribute {
         public DebuggerBrowsableAttribute(DebuggerBrowsableState state);
         public DebuggerBrowsableState State { get; }
     }
     public enum DebuggerBrowsableState {
         Collapsed = 2,
         Never = 0,
         RootHidden = 3,
     }
     public sealed class DebuggerDisplayAttribute : Attribute {
         public DebuggerDisplayAttribute(string value);
         public string Name { get; set; }
         public Type Target { get; set; }
         public string TargetTypeName { get; set; }
         public string Type { get; set; }
         public string Value { get; }
     }
     public sealed class DebuggerHiddenAttribute : Attribute {
         public DebuggerHiddenAttribute();
     }
     public sealed class DebuggerNonUserCodeAttribute : Attribute {
         public DebuggerNonUserCodeAttribute();
     }
     public sealed class DebuggerStepThroughAttribute : Attribute {
         public DebuggerStepThroughAttribute();
     }
     public sealed class DebuggerTypeProxyAttribute : Attribute {
         public DebuggerTypeProxyAttribute(string typeName);
         public DebuggerTypeProxyAttribute(Type type);
         public string ProxyTypeName { get; }
         public Type Target { get; set; }
         public string TargetTypeName { get; set; }
     }
     public class Stopwatch {
         public static readonly long Frequency;
         public static readonly bool IsHighResolution;
         public Stopwatch();
         public TimeSpan Elapsed { get; }
         public long ElapsedMilliseconds { get; }
         public long ElapsedTicks { get; }
         public bool IsRunning { get; }
         public static long GetTimestamp();
         public void Reset();
         public void Restart();
         public void Start();
         public static Stopwatch StartNew();
         public void Stop();
     }
 }
 namespace System.Diagnostics.CodeAnalysis {
     public sealed class SuppressMessageAttribute : Attribute {
         public SuppressMessageAttribute(string category, string checkId);
         public string Category { get; }
         public string CheckId { get; }
         public string Justification { get; set; }
         public string MessageId { get; set; }
         public string Scope { get; set; }
         public string Target { get; set; }
     }
 }
 namespace System.Globalization {
     public abstract class Calendar {
         public const int CurrentEra = 0;
         protected Calendar();
         public abstract int[] Eras { get; }
         public bool IsReadOnly { get; }
         public virtual DateTime MaxSupportedDateTime { get; }
         public virtual DateTime MinSupportedDateTime { get; }
         public virtual int TwoDigitYearMax { get; set; }
         public virtual DateTime AddDays(DateTime time, int days);
         public virtual DateTime AddHours(DateTime time, int hours);
         public virtual DateTime AddMilliseconds(DateTime time, double milliseconds);
         public virtual DateTime AddMinutes(DateTime time, int minutes);
         public abstract DateTime AddMonths(DateTime time, int months);
         public virtual DateTime AddSeconds(DateTime time, int seconds);
         public virtual DateTime AddWeeks(DateTime time, int weeks);
         public abstract DateTime AddYears(DateTime time, int years);
         public abstract int GetDayOfMonth(DateTime time);
         public abstract DayOfWeek GetDayOfWeek(DateTime time);
         public abstract int GetDayOfYear(DateTime time);
         public virtual int GetDaysInMonth(int year, int month);
         public abstract int GetDaysInMonth(int year, int month, int era);
         public virtual int GetDaysInYear(int year);
         public abstract int GetDaysInYear(int year, int era);
         public abstract int GetEra(DateTime time);
         public virtual int GetHour(DateTime time);
         public virtual int GetLeapMonth(int year, int era);
         public virtual double GetMilliseconds(DateTime time);
         public virtual int GetMinute(DateTime time);
         public abstract int GetMonth(DateTime time);
         public virtual int GetMonthsInYear(int year);
         public abstract int GetMonthsInYear(int year, int era);
         public virtual int GetSecond(DateTime time);
         public virtual int GetWeekOfYear(DateTime time, CalendarWeekRule rule, DayOfWeek firstDayOfWeek);
         public abstract int GetYear(DateTime time);
         public virtual bool IsLeapDay(int year, int month, int day);
         public abstract bool IsLeapDay(int year, int month, int day, int era);
         public virtual bool IsLeapMonth(int year, int month);
         public abstract bool IsLeapMonth(int year, int month, int era);
         public virtual bool IsLeapYear(int year);
         public abstract bool IsLeapYear(int year, int era);
         public virtual DateTime ToDateTime(int year, int month, int day, int hour, int minute, int second, int millisecond);
         public abstract DateTime ToDateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, int era);
         public virtual int ToFourDigitYear(int year);
     }
     public enum CalendarWeekRule {
         FirstDay = 0,
         FirstFourDayWeek = 2,
         FirstFullWeek = 1,
     }
     public static class CharUnicodeInfo {
         public static double GetNumericValue(char ch);
         public static double GetNumericValue(string s, int index);
         public static UnicodeCategory GetUnicodeCategory(char ch);
         public static UnicodeCategory GetUnicodeCategory(string s, int index);
     }
     public class CompareInfo {
         public virtual string Name { get; }
         public virtual int Compare(string string1, int offset1, int length1, string string2, int offset2, int length2);
         public virtual int Compare(string string1, int offset1, int length1, string string2, int offset2, int length2, CompareOptions options);
         public virtual int Compare(string string1, int offset1, string string2, int offset2);
         public virtual int Compare(string string1, int offset1, string string2, int offset2, CompareOptions options);
         public virtual int Compare(string string1, string string2);
         public virtual int Compare(string string1, string string2, CompareOptions options);
         public override bool Equals(object value);
         public static CompareInfo GetCompareInfo(string name);
         public override int GetHashCode();
         public virtual int IndexOf(string source, char value);
         public virtual int IndexOf(string source, char value, CompareOptions options);
         public virtual int IndexOf(string source, char value, int startIndex, CompareOptions options);
         public virtual int IndexOf(string source, char value, int startIndex, int count);
         public virtual int IndexOf(string source, char value, int startIndex, int count, CompareOptions options);
         public virtual int IndexOf(string source, string value);
         public virtual int IndexOf(string source, string value, CompareOptions options);
         public virtual int IndexOf(string source, string value, int startIndex, CompareOptions options);
         public virtual int IndexOf(string source, string value, int startIndex, int count);
         public virtual int IndexOf(string source, string value, int startIndex, int count, CompareOptions options);
         public virtual bool IsPrefix(string source, string prefix);
         public virtual bool IsPrefix(string source, string prefix, CompareOptions options);
         public virtual bool IsSuffix(string source, string suffix);
         public virtual bool IsSuffix(string source, string suffix, CompareOptions options);
         public virtual int LastIndexOf(string source, char value);
         public virtual int LastIndexOf(string source, char value, CompareOptions options);
         public virtual int LastIndexOf(string source, char value, int startIndex, CompareOptions options);
         public virtual int LastIndexOf(string source, char value, int startIndex, int count);
         public virtual int LastIndexOf(string source, char value, int startIndex, int count, CompareOptions options);
         public virtual int LastIndexOf(string source, string value);
         public virtual int LastIndexOf(string source, string value, CompareOptions options);
         public virtual int LastIndexOf(string source, string value, int startIndex, CompareOptions options);
         public virtual int LastIndexOf(string source, string value, int startIndex, int count);
         public virtual int LastIndexOf(string source, string value, int startIndex, int count, CompareOptions options);
         public override string ToString();
     }
     public enum CompareOptions {
         IgnoreCase = 1,
         IgnoreKanaType = 8,
         IgnoreNonSpace = 2,
         IgnoreSymbols = 4,
         IgnoreWidth = 16,
         None = 0,
         Ordinal = 1073741824,
         OrdinalIgnoreCase = 268435456,
         StringSort = 536870912,
     }
     public class CultureInfo : IFormatProvider {
         public CultureInfo(string name);
         public virtual Calendar Calendar { get; }
         public virtual CompareInfo CompareInfo { get; }
         public static CultureInfo CurrentCulture { get; }
         public static CultureInfo CurrentUICulture { get; }
         public virtual DateTimeFormatInfo DateTimeFormat { get; set; }
         public static CultureInfo DefaultThreadCurrentCulture { get; set; }
         public static CultureInfo DefaultThreadCurrentUICulture { get; set; }
         public virtual string DisplayName { get; }
         public virtual string EnglishName { get; }
         public static CultureInfo InvariantCulture { get; }
         public virtual bool IsNeutralCulture { get; }
         public bool IsReadOnly { get; }
         public virtual string Name { get; }
         public virtual string NativeName { get; }
         public virtual NumberFormatInfo NumberFormat { get; set; }
         public virtual Calendar[] OptionalCalendars { get; }
         public virtual CultureInfo Parent { get; }
         public virtual TextInfo TextInfo { get; }
         public virtual string TwoLetterISOLanguageName { get; }
         public virtual object Clone();
         public override bool Equals(object value);
         public virtual object GetFormat(Type formatType);
         public override int GetHashCode();
         public static CultureInfo ReadOnly(CultureInfo ci);
         public override string ToString();
     }
     public class CultureNotFoundException : ArgumentException {
         public CultureNotFoundException();
         public CultureNotFoundException(string message);
         public CultureNotFoundException(string message, Exception innerException);
         public CultureNotFoundException(string paramName, string message);
         public CultureNotFoundException(string message, string invalidCultureName, Exception innerException);
         public CultureNotFoundException(string paramName, string invalidCultureName, string message);
         public virtual string InvalidCultureName { get; }
         public override string Message { get; }
     }
     public sealed class DateTimeFormatInfo : IFormatProvider {
         public DateTimeFormatInfo();
         public string[] AbbreviatedDayNames { get; set; }
         public string[] AbbreviatedMonthGenitiveNames { get; set; }
         public string[] AbbreviatedMonthNames { get; set; }
         public string AMDesignator { get; set; }
         public Calendar Calendar { get; set; }
         public CalendarWeekRule CalendarWeekRule { get; set; }
         public static DateTimeFormatInfo CurrentInfo { get; }
         public string[] DayNames { get; set; }
         public DayOfWeek FirstDayOfWeek { get; set; }
         public string FullDateTimePattern { get; set; }
         public static DateTimeFormatInfo InvariantInfo { get; }
         public bool IsReadOnly { get; }
         public string LongDatePattern { get; set; }
         public string LongTimePattern { get; set; }
         public string MonthDayPattern { get; set; }
         public string[] MonthGenitiveNames { get; set; }
         public string[] MonthNames { get; set; }
         public string PMDesignator { get; set; }
         public string RFC1123Pattern { get; }
         public string ShortDatePattern { get; set; }
         public string[] ShortestDayNames { get; set; }
         public string ShortTimePattern { get; set; }
         public string SortableDateTimePattern { get; }
         public string UniversalSortableDateTimePattern { get; }
         public string YearMonthPattern { get; set; }
         public object Clone();
         public string GetAbbreviatedDayName(DayOfWeek dayofweek);
         public string GetAbbreviatedEraName(int era);
         public string GetAbbreviatedMonthName(int month);
         public string GetDayName(DayOfWeek dayofweek);
         public int GetEra(string eraName);
         public string GetEraName(int era);
         public object GetFormat(Type formatType);
         public static DateTimeFormatInfo GetInstance(IFormatProvider provider);
         public string GetMonthName(int month);
         public static DateTimeFormatInfo ReadOnly(DateTimeFormatInfo dtfi);
     }
     public enum DateTimeStyles {
         AdjustToUniversal = 16,
         AllowInnerWhite = 4,
         AllowLeadingWhite = 1,
         AllowTrailingWhite = 2,
         AllowWhiteSpaces = 7,
         AssumeLocal = 32,
         AssumeUniversal = 64,
         NoCurrentDateDefault = 8,
         None = 0,
         RoundtripKind = 128,
     }
     public sealed class NumberFormatInfo : IFormatProvider {
         public NumberFormatInfo();
         public int CurrencyDecimalDigits { get; set; }
         public string CurrencyDecimalSeparator { get; set; }
         public string CurrencyGroupSeparator { get; set; }
         public int[] CurrencyGroupSizes { get; set; }
         public int CurrencyNegativePattern { get; set; }
         public int CurrencyPositivePattern { get; set; }
         public string CurrencySymbol { get; set; }
         public static NumberFormatInfo CurrentInfo { get; }
         public static NumberFormatInfo InvariantInfo { get; }
         public bool IsReadOnly { get; }
         public string NaNSymbol { get; set; }
         public string NegativeInfinitySymbol { get; set; }
         public string NegativeSign { get; set; }
         public int NumberDecimalDigits { get; set; }
         public string NumberDecimalSeparator { get; set; }
         public string NumberGroupSeparator { get; set; }
         public int[] NumberGroupSizes { get; set; }
         public int NumberNegativePattern { get; set; }
         public int PercentDecimalDigits { get; set; }
         public string PercentDecimalSeparator { get; set; }
         public string PercentGroupSeparator { get; set; }
         public int[] PercentGroupSizes { get; set; }
         public int PercentNegativePattern { get; set; }
         public int PercentPositivePattern { get; set; }
         public string PercentSymbol { get; set; }
         public string PerMilleSymbol { get; set; }
         public string PositiveInfinitySymbol { get; set; }
         public string PositiveSign { get; set; }
         public object Clone();
         public object GetFormat(Type formatType);
         public static NumberFormatInfo GetInstance(IFormatProvider formatProvider);
         public static NumberFormatInfo ReadOnly(NumberFormatInfo nfi);
     }
     public enum NumberStyles {
         AllowCurrencySymbol = 256,
         AllowDecimalPoint = 32,
         AllowExponent = 128,
         AllowHexSpecifier = 512,
         AllowLeadingSign = 4,
         AllowLeadingWhite = 1,
         AllowParentheses = 16,
         AllowThousands = 64,
         AllowTrailingSign = 8,
         AllowTrailingWhite = 2,
         Any = 511,
         Currency = 383,
         Float = 167,
         HexNumber = 515,
         Integer = 7,
         None = 0,
         Number = 111,
     }
     public class RegionInfo {
         public RegionInfo(string name);
         public virtual string CurrencySymbol { get; }
         public static RegionInfo CurrentRegion { get; }
         public virtual string DisplayName { get; }
         public virtual string EnglishName { get; }
         public virtual bool IsMetric { get; }
         public virtual string ISOCurrencySymbol { get; }
         public virtual string Name { get; }
         public virtual string NativeName { get; }
         public virtual string TwoLetterISORegionName { get; }
         public override bool Equals(object value);
         public override int GetHashCode();
         public override string ToString();
     }
     public class StringInfo {
         public StringInfo();
         public StringInfo(string value);
         public int LengthInTextElements { get; }
         public string String { get; set; }
         public override bool Equals(object value);
         public override int GetHashCode();
         public static string GetNextTextElement(string str);
         public static string GetNextTextElement(string str, int index);
         public static TextElementEnumerator GetTextElementEnumerator(string str);
         public static TextElementEnumerator GetTextElementEnumerator(string str, int index);
         public static int[] ParseCombiningCharacters(string str);
     }
     public class TextElementEnumerator : IEnumerator {
         public object Current { get; }
         public int ElementIndex { get; }
         public string GetTextElement();
         public bool MoveNext();
         public void Reset();
     }
     public class TextInfo {
         public string CultureName { get; }
         public bool IsReadOnly { get; }
         public virtual string ListSeparator { get; set; }
         public override bool Equals(object obj);
         public override int GetHashCode();
         public virtual char ToLower(char c);
         public virtual string ToLower(string str);
         public override string ToString();
         public virtual char ToUpper(char c);
         public virtual string ToUpper(string str);
     }
     public enum TimeSpanStyles {
         AssumeNegative = 1,
         None = 0,
     }
     public enum UnicodeCategory {
         ClosePunctuation = 21,
         ConnectorPunctuation = 18,
         Control = 14,
         CurrencySymbol = 26,
         DashPunctuation = 19,
         DecimalDigitNumber = 8,
         EnclosingMark = 7,
         FinalQuotePunctuation = 23,
         Format = 15,
         InitialQuotePunctuation = 22,
         LetterNumber = 9,
         LineSeparator = 12,
         LowercaseLetter = 1,
         MathSymbol = 25,
         ModifierLetter = 3,
         ModifierSymbol = 27,
         NonSpacingMark = 5,
         OpenPunctuation = 20,
         OtherLetter = 4,
         OtherNotAssigned = 29,
         OtherNumber = 10,
         OtherPunctuation = 24,
         OtherSymbol = 28,
         ParagraphSeparator = 13,
         PrivateUse = 17,
         SpaceSeparator = 11,
         SpacingCombiningMark = 6,
         Surrogate = 16,
         TitlecaseLetter = 2,
         UppercaseLetter = 0,
     }
 }
 namespace System.IO {
     public class BinaryReader : IDisposable {
         public BinaryReader(Stream input);
         public BinaryReader(Stream input, Encoding encoding);
         public BinaryReader(Stream input, Encoding encoding, bool leaveOpen);
         public virtual Stream BaseStream { get; }
         public void Dispose();
         protected virtual void Dispose(bool disposing);
         protected virtual void FillBuffer(int numBytes);
         public virtual int PeekChar();
         public virtual int Read();
         public virtual int Read(byte[] buffer, int index, int count);
         public virtual int Read(char[] buffer, int index, int count);
         protected internal int Read7BitEncodedInt();
         public virtual bool ReadBoolean();
         public virtual byte ReadByte();
         public virtual byte[] ReadBytes(int count);
         public virtual char ReadChar();
         public virtual char[] ReadChars(int count);
         public virtual decimal ReadDecimal();
         public virtual double ReadDouble();
         public virtual short ReadInt16();
         public virtual int ReadInt32();
         public virtual long ReadInt64();
         public virtual sbyte ReadSByte();
         public virtual float ReadSingle();
         public virtual string ReadString();
         public virtual ushort ReadUInt16();
         public virtual uint ReadUInt32();
         public virtual ulong ReadUInt64();
     }
     public class BinaryWriter : IDisposable {
         public static readonly BinaryWriter Null;
         protected Stream OutStream;
         protected BinaryWriter();
         public BinaryWriter(Stream output);
         public BinaryWriter(Stream output, Encoding encoding);
         public BinaryWriter(Stream output, Encoding encoding, bool leaveOpen);
         public virtual Stream BaseStream { get; }
         public void Dispose();
         protected virtual void Dispose(bool disposing);
         public virtual void Flush();
         public virtual long Seek(int offset, SeekOrigin origin);
         public virtual void Write(bool value);
         public virtual void Write(byte value);
         public virtual void Write(byte[] buffer);
         public virtual void Write(byte[] buffer, int index, int count);
         public virtual void Write(char ch);
         public virtual void Write(char[] chars);
         public virtual void Write(char[] chars, int index, int count);
         public virtual void Write(decimal value);
         public virtual void Write(double value);
         public virtual void Write(short value);
         public virtual void Write(int value);
         public virtual void Write(long value);
         public virtual void Write(sbyte value);
         public virtual void Write(float value);
         public virtual void Write(string value);
         public virtual void Write(ushort value);
         public virtual void Write(uint value);
         public virtual void Write(ulong value);
         protected void Write7BitEncodedInt(int value);
     }
     public class EndOfStreamException : IOException {
         public EndOfStreamException();
         public EndOfStreamException(string message);
         public EndOfStreamException(string message, Exception innerException);
     }
     public class FileNotFoundException : IOException {
         public FileNotFoundException();
         public FileNotFoundException(string message);
         public FileNotFoundException(string message, Exception innerException);
         public FileNotFoundException(string message, string fileName);
         public FileNotFoundException(string message, string fileName, Exception innerException);
         public string FileName { get; }
         public override string Message { get; }
         public override string ToString();
     }
     public sealed class InvalidDataException : Exception {
         public InvalidDataException();
         public InvalidDataException(string message);
         public InvalidDataException(string message, Exception innerException);
     }
     public class IOException : Exception {
         public IOException();
         public IOException(string message);
         public IOException(string message, Exception innerException);
         public IOException(string message, int hresult);
     }
     public class MemoryStream : Stream {
         public MemoryStream();
         public MemoryStream(byte[] buffer);
         public MemoryStream(byte[] buffer, bool writable);
         public MemoryStream(byte[] buffer, int index, int count);
         public MemoryStream(byte[] buffer, int index, int count, bool writable);
         public MemoryStream(int capacity);
         public override bool CanRead { get; }
         public override bool CanSeek { get; }
         public override bool CanWrite { get; }
         public virtual int Capacity { get; set; }
         public override long Length { get; }
         public override long Position { get; set; }
         protected override void Dispose(bool disposing);
         public override void Flush();
         public override Task FlushAsync(CancellationToken cancellationToken);
         public override int Read(byte[] buffer, int offset, int count);
         public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken);
         public override int ReadByte();
         public override long Seek(long offset, SeekOrigin loc);
         public override void SetLength(long value);
         public virtual byte[] ToArray();
         public override void Write(byte[] buffer, int offset, int count);
         public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken);
         public override void WriteByte(byte value);
         public virtual void WriteTo(Stream stream);
     }
     public static class Path {
         public static string ChangeExtension(string path, string extension);
         public static string Combine(params string[] paths);
         public static string GetDirectoryName(string path);
         public static string GetExtension(string path);
         public static string GetFileName(string path);
         public static string GetFileNameWithoutExtension(string path);
         public static char[] GetInvalidFileNameChars();
         public static char[] GetInvalidPathChars();
         public static string GetPathRoot(string path);
         public static string GetRandomFileName();
         public static bool HasExtension(string path);
         public static bool IsPathRooted(string path);
     }
     public enum SeekOrigin {
         Begin = 0,
         Current = 1,
         End = 2,
     }
     public abstract class Stream : IDisposable {
         public static readonly Stream Null;
         protected Stream();
         public abstract bool CanRead { get; }
         public abstract bool CanSeek { get; }
         public virtual bool CanTimeout { get; }
         public abstract bool CanWrite { get; }
         public abstract long Length { get; }
         public abstract long Position { get; set; }
         public virtual int ReadTimeout { get; set; }
         public virtual int WriteTimeout { get; set; }
         public void CopyTo(Stream destination);
         public void CopyTo(Stream destination, int bufferSize);
         public Task CopyToAsync(Stream destination);
         public Task CopyToAsync(Stream destination, int bufferSize);
         public virtual Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken);
         public void Dispose();
         protected virtual void Dispose(bool disposing);
         public abstract void Flush();
         public Task FlushAsync();
         public virtual Task FlushAsync(CancellationToken cancellationToken);
         public abstract int Read(byte[] buffer, int offset, int count);
         public Task<int> ReadAsync(byte[] buffer, int offset, int count);
         public virtual Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken);
         public virtual int ReadByte();
         public abstract long Seek(long offset, SeekOrigin origin);
         public abstract void SetLength(long value);
         public abstract void Write(byte[] buffer, int offset, int count);
         public Task WriteAsync(byte[] buffer, int offset, int count);
         public virtual Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken);
         public virtual void WriteByte(byte value);
     }
     public class StreamReader : TextReader {
         public static readonly new StreamReader Null;
         public StreamReader(Stream stream);
         public StreamReader(Stream stream, bool detectEncodingFromByteOrderMarks);
         public StreamReader(Stream stream, Encoding encoding);
         public StreamReader(Stream stream, Encoding encoding, bool detectEncodingFromByteOrderMarks);
         public StreamReader(Stream stream, Encoding encoding, bool detectEncodingFromByteOrderMarks, int bufferSize);
         public StreamReader(Stream stream, Encoding encoding, bool detectEncodingFromByteOrderMarks, int bufferSize, bool leaveOpen);
         public virtual Stream BaseStream { get; }
         public virtual Encoding CurrentEncoding { get; }
         public bool EndOfStream { get; }
         public void DiscardBufferedData();
         protected override void Dispose(bool disposing);
         public override int Peek();
         public override int Read();
         public override int Read(char[] buffer, int index, int count);
         public override Task<int> ReadAsync(char[] buffer, int index, int count);
         public override int ReadBlock(char[] buffer, int index, int count);
         public override Task<int> ReadBlockAsync(char[] buffer, int index, int count);
         public override string ReadLine();
         public override Task<string> ReadLineAsync();
         public override string ReadToEnd();
         public override Task<string> ReadToEndAsync();
     }
     public class StreamWriter : TextWriter {
         public static readonly new StreamWriter Null;
         public StreamWriter(Stream stream);
         public StreamWriter(Stream stream, Encoding encoding);
         public StreamWriter(Stream stream, Encoding encoding, int bufferSize);
         public StreamWriter(Stream stream, Encoding encoding, int bufferSize, bool leaveOpen);
         public virtual bool AutoFlush { get; set; }
         public virtual Stream BaseStream { get; }
         public override Encoding Encoding { get; }
         protected override void Dispose(bool disposing);
         public override void Flush();
         public override Task FlushAsync();
         public override void Write(char value);
         public override void Write(char[] buffer);
         public override void Write(char[] buffer, int index, int count);
         public override void Write(string value);
         public override Task WriteAsync(char value);
         public override Task WriteAsync(char[] buffer, int index, int count);
         public override Task WriteAsync(string value);
         public override Task WriteLineAsync();
         public override Task WriteLineAsync(char value);
         public override Task WriteLineAsync(char[] buffer, int index, int count);
         public override Task WriteLineAsync(string value);
     }
     public class StringReader : TextReader {
         public StringReader(string s);
         protected override void Dispose(bool disposing);
         public override int Peek();
         public override int Read();
         public override int Read(char[] buffer, int index, int count);
         public override Task<int> ReadAsync(char[] buffer, int index, int count);
         public override Task<int> ReadBlockAsync(char[] buffer, int index, int count);
         public override string ReadLine();
         public override Task<string> ReadLineAsync();
         public override string ReadToEnd();
         public override Task<string> ReadToEndAsync();
     }
     public class StringWriter : TextWriter {
         public StringWriter();
         public StringWriter(IFormatProvider formatProvider);
         public StringWriter(StringBuilder sb);
         public StringWriter(StringBuilder sb, IFormatProvider formatProvider);
         public override Encoding Encoding { get; }
         protected override void Dispose(bool disposing);
         public override Task FlushAsync();
         public virtual StringBuilder GetStringBuilder();
         public override string ToString();
         public override void Write(char value);
         public override void Write(char[] buffer, int index, int count);
         public override void Write(string value);
         public override Task WriteAsync(char value);
         public override Task WriteAsync(char[] buffer, int index, int count);
         public override Task WriteAsync(string value);
         public override Task WriteLineAsync(char value);
         public override Task WriteLineAsync(char[] buffer, int index, int count);
         public override Task WriteLineAsync(string value);
     }
     public abstract class TextReader : IDisposable {
         public static readonly TextReader Null;
         protected TextReader();
         public void Dispose();
         protected virtual void Dispose(bool disposing);
         public virtual int Peek();
         public virtual int Read();
         public virtual int Read(char[] buffer, int index, int count);
         public virtual Task<int> ReadAsync(char[] buffer, int index, int count);
         public virtual int ReadBlock(char[] buffer, int index, int count);
         public virtual Task<int> ReadBlockAsync(char[] buffer, int index, int count);
         public virtual string ReadLine();
         public virtual Task<string> ReadLineAsync();
         public virtual string ReadToEnd();
         public virtual Task<string> ReadToEndAsync();
     }
     public abstract class TextWriter : IDisposable {
         protected char[] CoreNewLine;
         public static readonly TextWriter Null;
         protected TextWriter();
         protected TextWriter(IFormatProvider formatProvider);
         public abstract Encoding Encoding { get; }
         public virtual IFormatProvider FormatProvider { get; }
         public virtual string NewLine { get; set; }
         public void Dispose();
         protected virtual void Dispose(bool disposing);
         public virtual void Flush();
         public virtual Task FlushAsync();
         public virtual void Write(bool value);
         public abstract void Write(char value);
         public virtual void Write(char[] buffer);
         public virtual void Write(char[] buffer, int index, int count);
         public virtual void Write(decimal value);
         public virtual void Write(double value);
         public virtual void Write(int value);
         public virtual void Write(long value);
         public virtual void Write(object value);
         public virtual void Write(float value);
         public virtual void Write(string value);
         public virtual void Write(string format, params object[] arg);
         public virtual void Write(uint value);
         public virtual void Write(ulong value);
         public virtual Task WriteAsync(char value);
         public Task WriteAsync(char[] buffer);
         public virtual Task WriteAsync(char[] buffer, int index, int count);
         public virtual Task WriteAsync(string value);
         public virtual void WriteLine();
         public virtual void WriteLine(bool value);
         public virtual void WriteLine(char value);
         public virtual void WriteLine(char[] buffer);
         public virtual void WriteLine(char[] buffer, int index, int count);
         public virtual void WriteLine(decimal value);
         public virtual void WriteLine(double value);
         public virtual void WriteLine(int value);
         public virtual void WriteLine(long value);
         public virtual void WriteLine(object value);
         public virtual void WriteLine(float value);
         public virtual void WriteLine(string value);
         public virtual void WriteLine(string format, params object[] arg);
         public virtual void WriteLine(uint value);
         public virtual void WriteLine(ulong value);
         public virtual Task WriteLineAsync();
         public virtual Task WriteLineAsync(char value);
         public Task WriteLineAsync(char[] buffer);
         public virtual Task WriteLineAsync(char[] buffer, int index, int count);
         public virtual Task WriteLineAsync(string value);
     }
 }
 namespace System.Linq {
     public static class Enumerable {
         public static TSource Aggregate<TSource>(this IEnumerable<TSource> source, Func<TSource, TSource, TSource> func);
         public static TAccumulate Aggregate<TSource, TAccumulate>(this IEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> func);
         public static TResult Aggregate<TSource, TAccumulate, TResult>(this IEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> func, Func<TAccumulate, TResult> resultSelector);
         public static bool All<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate);
         public static bool Any<TSource>(this IEnumerable<TSource> source);
         public static bool Any<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate);
         public static IEnumerable<TSource> AsEnumerable<TSource>(this IEnumerable<TSource> source);
         public static double Average<TSource>(this IEnumerable<TSource> source, Func<TSource, int> selector);
         public static double Average<TSource>(this IEnumerable<TSource> source, Func<TSource, long> selector);
         public static double Average<TSource>(this IEnumerable<TSource> source, Func<TSource, double> selector);
         public static Nullable<double> Average<TSource>(this IEnumerable<TSource> source, Func<TSource, Nullable<int>> selector);
         public static Nullable<double> Average<TSource>(this IEnumerable<TSource> source, Func<TSource, Nullable<long>> selector);
         public static float Average<TSource>(this IEnumerable<TSource> source, Func<TSource, float> selector);
         public static decimal Average<TSource>(this IEnumerable<TSource> source, Func<TSource, decimal> selector);
         public static Nullable<double> Average<TSource>(this IEnumerable<TSource> source, Func<TSource, Nullable<double>> selector);
         public static Nullable<float> Average<TSource>(this IEnumerable<TSource> source, Func<TSource, Nullable<float>> selector);
         public static Nullable<decimal> Average<TSource>(this IEnumerable<TSource> source, Func<TSource, Nullable<decimal>> selector);
         public static double Average(this IEnumerable<int> source);
         public static double Average(this IEnumerable<long> source);
         public static double Average(this IEnumerable<double> source);
         public static Nullable<double> Average(this IEnumerable<Nullable<int>> source);
         public static Nullable<double> Average(this IEnumerable<Nullable<long>> source);
         public static float Average(this IEnumerable<float> source);
         public static decimal Average(this IEnumerable<decimal> source);
         public static Nullable<double> Average(this IEnumerable<Nullable<double>> source);
         public static Nullable<float> Average(this IEnumerable<Nullable<float>> source);
         public static Nullable<decimal> Average(this IEnumerable<Nullable<decimal>> source);
         public static IEnumerable<TResult> Cast<TResult>(this IEnumerable source);
         public static IEnumerable<TSource> Concat<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second);
         public static bool Contains<TSource>(this IEnumerable<TSource> source, TSource value);
         public static bool Contains<TSource>(this IEnumerable<TSource> source, TSource value, IEqualityComparer<TSource> comparer);
         public static int Count<TSource>(this IEnumerable<TSource> source);
         public static int Count<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate);
         public static IEnumerable<TSource> DefaultIfEmpty<TSource>(this IEnumerable<TSource> source);
         public static IEnumerable<TSource> DefaultIfEmpty<TSource>(this IEnumerable<TSource> source, TSource defaultValue);
         public static IEnumerable<TSource> Distinct<TSource>(this IEnumerable<TSource> source);
         public static IEnumerable<TSource> Distinct<TSource>(this IEnumerable<TSource> source, IEqualityComparer<TSource> comparer);
         public static TSource ElementAt<TSource>(this IEnumerable<TSource> source, int index);
         public static TSource ElementAtOrDefault<TSource>(this IEnumerable<TSource> source, int index);
         public static IEnumerable<TResult> Empty<TResult>();
         public static IEnumerable<TSource> Except<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second);
         public static IEnumerable<TSource> Except<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer);
         public static TSource First<TSource>(this IEnumerable<TSource> source);
         public static TSource First<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate);
         public static TSource FirstOrDefault<TSource>(this IEnumerable<TSource> source);
         public static TSource FirstOrDefault<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate);
         public static IEnumerable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector);
         public static IEnumerable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer);
         public static IEnumerable<IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector);
         public static IEnumerable<TResult> GroupBy<TSource, TKey, TResult>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TKey, IEnumerable<TSource>, TResult> resultSelector);
         public static IEnumerable<IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer);
         public static IEnumerable<TResult> GroupBy<TSource, TKey, TResult>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TKey, IEnumerable<TSource>, TResult> resultSelector, IEqualityComparer<TKey> comparer);
         public static IEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<TKey, IEnumerable<TElement>, TResult> resultSelector);
         public static IEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<TKey, IEnumerable<TElement>, TResult> resultSelector, IEqualityComparer<TKey> comparer);
         public static IEnumerable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this IEnumerable<TOuter> outer, IEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, IEnumerable<TInner>, TResult> resultSelector);
         public static IEnumerable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this IEnumerable<TOuter> outer, IEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, IEnumerable<TInner>, TResult> resultSelector, IEqualityComparer<TKey> comparer);
         public static IEnumerable<TSource> Intersect<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second);
         public static IEnumerable<TSource> Intersect<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer);
         public static IEnumerable<TResult> Join<TOuter, TInner, TKey, TResult>(this IEnumerable<TOuter> outer, IEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, TInner, TResult> resultSelector);
         public static IEnumerable<TResult> Join<TOuter, TInner, TKey, TResult>(this IEnumerable<TOuter> outer, IEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, TInner, TResult> resultSelector, IEqualityComparer<TKey> comparer);
         public static TSource Last<TSource>(this IEnumerable<TSource> source);
         public static TSource Last<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate);
         public static TSource LastOrDefault<TSource>(this IEnumerable<TSource> source);
         public static TSource LastOrDefault<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate);
         public static long LongCount<TSource>(this IEnumerable<TSource> source);
         public static long LongCount<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate);
         public static TSource Max<TSource>(this IEnumerable<TSource> source);
         public static int Max<TSource>(this IEnumerable<TSource> source, Func<TSource, int> selector);
         public static long Max<TSource>(this IEnumerable<TSource> source, Func<TSource, long> selector);
         public static double Max<TSource>(this IEnumerable<TSource> source, Func<TSource, double> selector);
         public static Nullable<int> Max<TSource>(this IEnumerable<TSource> source, Func<TSource, Nullable<int>> selector);
         public static Nullable<long> Max<TSource>(this IEnumerable<TSource> source, Func<TSource, Nullable<long>> selector);
         public static float Max<TSource>(this IEnumerable<TSource> source, Func<TSource, float> selector);
         public static decimal Max<TSource>(this IEnumerable<TSource> source, Func<TSource, decimal> selector);
         public static Nullable<double> Max<TSource>(this IEnumerable<TSource> source, Func<TSource, Nullable<double>> selector);
         public static Nullable<float> Max<TSource>(this IEnumerable<TSource> source, Func<TSource, Nullable<float>> selector);
         public static Nullable<decimal> Max<TSource>(this IEnumerable<TSource> source, Func<TSource, Nullable<decimal>> selector);
         public static TResult Max<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, TResult> selector);
         public static int Max(this IEnumerable<int> source);
         public static long Max(this IEnumerable<long> source);
         public static double Max(this IEnumerable<double> source);
         public static Nullable<int> Max(this IEnumerable<Nullable<int>> source);
         public static Nullable<long> Max(this IEnumerable<Nullable<long>> source);
         public static float Max(this IEnumerable<float> source);
         public static decimal Max(this IEnumerable<decimal> source);
         public static Nullable<double> Max(this IEnumerable<Nullable<double>> source);
         public static Nullable<float> Max(this IEnumerable<Nullable<float>> source);
         public static Nullable<decimal> Max(this IEnumerable<Nullable<decimal>> source);
         public static TSource Min<TSource>(this IEnumerable<TSource> source);
         public static int Min<TSource>(this IEnumerable<TSource> source, Func<TSource, int> selector);
         public static long Min<TSource>(this IEnumerable<TSource> source, Func<TSource, long> selector);
         public static double Min<TSource>(this IEnumerable<TSource> source, Func<TSource, double> selector);
         public static Nullable<int> Min<TSource>(this IEnumerable<TSource> source, Func<TSource, Nullable<int>> selector);
         public static Nullable<long> Min<TSource>(this IEnumerable<TSource> source, Func<TSource, Nullable<long>> selector);
         public static float Min<TSource>(this IEnumerable<TSource> source, Func<TSource, float> selector);
         public static decimal Min<TSource>(this IEnumerable<TSource> source, Func<TSource, decimal> selector);
         public static Nullable<double> Min<TSource>(this IEnumerable<TSource> source, Func<TSource, Nullable<double>> selector);
         public static Nullable<float> Min<TSource>(this IEnumerable<TSource> source, Func<TSource, Nullable<float>> selector);
         public static Nullable<decimal> Min<TSource>(this IEnumerable<TSource> source, Func<TSource, Nullable<decimal>> selector);
         public static TResult Min<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, TResult> selector);
         public static int Min(this IEnumerable<int> source);
         public static long Min(this IEnumerable<long> source);
         public static double Min(this IEnumerable<double> source);
         public static Nullable<int> Min(this IEnumerable<Nullable<int>> source);
         public static Nullable<long> Min(this IEnumerable<Nullable<long>> source);
         public static float Min(this IEnumerable<float> source);
         public static decimal Min(this IEnumerable<decimal> source);
         public static Nullable<double> Min(this IEnumerable<Nullable<double>> source);
         public static Nullable<float> Min(this IEnumerable<Nullable<float>> source);
         public static Nullable<decimal> Min(this IEnumerable<Nullable<decimal>> source);
         public static IEnumerable<TResult> OfType<TResult>(this IEnumerable source);
         public static IOrderedEnumerable<TSource> OrderBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector);
         public static IOrderedEnumerable<TSource> OrderBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer);
         public static IOrderedEnumerable<TSource> OrderByDescending<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector);
         public static IOrderedEnumerable<TSource> OrderByDescending<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer);
         public static IEnumerable<int> Range(int start, int count);
         public static IEnumerable<TResult> Repeat<TResult>(TResult element, int count);
         public static IEnumerable<TSource> Reverse<TSource>(this IEnumerable<TSource> source);
         public static IEnumerable<TResult> Select<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, TResult> selector);
         public static IEnumerable<TResult> Select<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, int, TResult> selector);
         public static IEnumerable<TResult> SelectMany<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, IEnumerable<TResult>> selector);
         public static IEnumerable<TResult> SelectMany<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, int, IEnumerable<TResult>> selector);
         public static IEnumerable<TResult> SelectMany<TSource, TCollection, TResult>(this IEnumerable<TSource> source, Func<TSource, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector);
         public static IEnumerable<TResult> SelectMany<TSource, TCollection, TResult>(this IEnumerable<TSource> source, Func<TSource, int, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector);
         public static bool SequenceEqual<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second);
         public static bool SequenceEqual<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer);
         public static TSource Single<TSource>(this IEnumerable<TSource> source);
         public static TSource Single<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate);
         public static TSource SingleOrDefault<TSource>(this IEnumerable<TSource> source);
         public static TSource SingleOrDefault<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate);
         public static IEnumerable<TSource> Skip<TSource>(this IEnumerable<TSource> source, int count);
         public static IEnumerable<TSource> SkipWhile<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate);
         public static IEnumerable<TSource> SkipWhile<TSource>(this IEnumerable<TSource> source, Func<TSource, int, bool> predicate);
         public static int Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, int> selector);
         public static long Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, long> selector);
         public static double Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, double> selector);
         public static Nullable<int> Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, Nullable<int>> selector);
         public static Nullable<long> Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, Nullable<long>> selector);
         public static float Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, float> selector);
         public static decimal Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, decimal> selector);
         public static Nullable<double> Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, Nullable<double>> selector);
         public static Nullable<float> Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, Nullable<float>> selector);
         public static Nullable<decimal> Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, Nullable<decimal>> selector);
         public static int Sum(this IEnumerable<int> source);
         public static long Sum(this IEnumerable<long> source);
         public static double Sum(this IEnumerable<double> source);
         public static Nullable<int> Sum(this IEnumerable<Nullable<int>> source);
         public static Nullable<long> Sum(this IEnumerable<Nullable<long>> source);
         public static float Sum(this IEnumerable<float> source);
         public static decimal Sum(this IEnumerable<decimal> source);
         public static Nullable<double> Sum(this IEnumerable<Nullable<double>> source);
         public static Nullable<float> Sum(this IEnumerable<Nullable<float>> source);
         public static Nullable<decimal> Sum(this IEnumerable<Nullable<decimal>> source);
         public static IEnumerable<TSource> Take<TSource>(this IEnumerable<TSource> source, int count);
         public static IEnumerable<TSource> TakeWhile<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate);
         public static IEnumerable<TSource> TakeWhile<TSource>(this IEnumerable<TSource> source, Func<TSource, int, bool> predicate);
         public static IOrderedEnumerable<TSource> ThenBy<TSource, TKey>(this IOrderedEnumerable<TSource> source, Func<TSource, TKey> keySelector);
         public static IOrderedEnumerable<TSource> ThenBy<TSource, TKey>(this IOrderedEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer);
         public static IOrderedEnumerable<TSource> ThenByDescending<TSource, TKey>(this IOrderedEnumerable<TSource> source, Func<TSource, TKey> keySelector);
         public static IOrderedEnumerable<TSource> ThenByDescending<TSource, TKey>(this IOrderedEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer);
         public static TSource[] ToArray<TSource>(this IEnumerable<TSource> source);
         public static Dictionary<TKey, TSource> ToDictionary<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector);
         public static Dictionary<TKey, TSource> ToDictionary<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer);
         public static Dictionary<TKey, TElement> ToDictionary<TSource, TKey, TElement>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector);
         public static Dictionary<TKey, TElement> ToDictionary<TSource, TKey, TElement>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer);
         public static List<TSource> ToList<TSource>(this IEnumerable<TSource> source);
         public static ILookup<TKey, TSource> ToLookup<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector);
         public static ILookup<TKey, TSource> ToLookup<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer);
         public static ILookup<TKey, TElement> ToLookup<TSource, TKey, TElement>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector);
         public static ILookup<TKey, TElement> ToLookup<TSource, TKey, TElement>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer);
         public static IEnumerable<TSource> Union<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second);
         public static IEnumerable<TSource> Union<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer);
         public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate);
         public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, Func<TSource, int, bool> predicate);
         public static IEnumerable<TResult> Zip<TFirst, TSecond, TResult>(this IEnumerable<TFirst> first, IEnumerable<TSecond> second, Func<TFirst, TSecond, TResult> resultSelector);
     }
     public interface IGrouping<out TKey, out TElement> : IEnumerable, IEnumerable<TElement> {
         TKey Key { get; }
     }
     public interface ILookup<TKey, TElement> : IEnumerable, IEnumerable<IGrouping<TKey, TElement>> {
         int Count { get; }
         IEnumerable<TElement> this[TKey key] { get; }
         bool Contains(TKey key);
     }
     public interface IOrderedEnumerable<TElement> : IEnumerable, IEnumerable<TElement> {
         IOrderedEnumerable<TElement> CreateOrderedEnumerable<TKey>(Func<TElement, TKey> keySelector, IComparer<TKey> comparer, bool descending);
     }
     public interface IOrderedQueryable : IEnumerable, IQueryable
     public interface IOrderedQueryable<out T> : IEnumerable, IEnumerable<T>, IOrderedQueryable, IQueryable, IQueryable<T>
     public interface IQueryable : IEnumerable {
         Type ElementType { get; }
         Expression Expression { get; }
         IQueryProvider Provider { get; }
     }
     public interface IQueryable<out T> : IEnumerable, IEnumerable<T>, IQueryable
     public interface IQueryProvider {
         IQueryable<TElement> CreateQuery<TElement>(Expression expression);
         IQueryable CreateQuery(Expression expression);
         TResult Execute<TResult>(Expression expression);
         object Execute(Expression expression);
     }
     public class Lookup<TKey, TElement> : IEnumerable, IEnumerable<IGrouping<TKey, TElement>>, ILookup<TKey, TElement> {
         public int Count { get; }
         public IEnumerable<TElement> this[TKey key] { get; }
         public IEnumerable<TResult> ApplyResultSelector<TResult>(Func<TKey, IEnumerable<TElement>, TResult> resultSelector);
         public bool Contains(TKey key);
         public IEnumerator<IGrouping<TKey, TElement>> GetEnumerator();
     }
 }
 namespace System.Linq.Expressions {
     public class BinaryExpression : Expression {
         public override bool CanReduce { get; }
         public LambdaExpression Conversion { get; }
         public bool IsLifted { get; }
         public bool IsLiftedToNull { get; }
         public Expression Left { get; }
         public MethodInfo Method { get; }
         public Expression Right { get; }
         protected internal override Expression Accept(ExpressionVisitor visitor);
         public override Expression Reduce();
         public BinaryExpression Update(Expression left, LambdaExpression conversion, Expression right);
     }
     public class BlockExpression : Expression {
         public ReadOnlyCollection<Expression> Expressions { get; }
         public sealed override ExpressionType NodeType { get; }
         public Expression Result { get; }
         public override Type Type { get; }
         public ReadOnlyCollection<ParameterExpression> Variables { get; }
         protected internal override Expression Accept(ExpressionVisitor visitor);
         public BlockExpression Update(IEnumerable<ParameterExpression> variables, IEnumerable<Expression> expressions);
     }
     public sealed class CatchBlock {
         public Expression Body { get; }
         public Expression Filter { get; }
         public Type Test { get; }
         public ParameterExpression Variable { get; }
         public override string ToString();
         public CatchBlock Update(ParameterExpression variable, Expression filter, Expression body);
     }
     public class ConditionalExpression : Expression {
         public Expression IfFalse { get; }
         public Expression IfTrue { get; }
         public sealed override ExpressionType NodeType { get; }
         public Expression Test { get; }
         public override Type Type { get; }
         protected internal override Expression Accept(ExpressionVisitor visitor);
         public ConditionalExpression Update(Expression test, Expression ifTrue, Expression ifFalse);
     }
     public class ConstantExpression : Expression {
         public sealed override ExpressionType NodeType { get; }
         public override Type Type { get; }
         public object Value { get; }
         protected internal override Expression Accept(ExpressionVisitor visitor);
     }
     public class DebugInfoExpression : Expression {
         public SymbolDocumentInfo Document { get; }
         public virtual int EndColumn { get; }
         public virtual int EndLine { get; }
         public virtual bool IsClear { get; }
         public sealed override ExpressionType NodeType { get; }
         public virtual int StartColumn { get; }
         public virtual int StartLine { get; }
         public sealed override Type Type { get; }
         protected internal override Expression Accept(ExpressionVisitor visitor);
     }
     public sealed class DefaultExpression : Expression {
         public sealed override ExpressionType NodeType { get; }
         public sealed override Type Type { get; }
     }
     public sealed class ElementInit {
         public MethodInfo AddMethod { get; }
         public ReadOnlyCollection<Expression> Arguments { get; }
         public override string ToString();
         public ElementInit Update(IEnumerable<Expression> arguments);
     }
     public abstract class Expression {
         protected Expression();
         public virtual bool CanReduce { get; }
         public virtual ExpressionType NodeType { get; }
         public virtual Type Type { get; }
         protected internal virtual Expression Accept(ExpressionVisitor visitor);
         public static BinaryExpression Add(Expression left, Expression right);
         public static BinaryExpression Add(Expression left, Expression right, MethodInfo method);
         public static BinaryExpression AddAssign(Expression left, Expression right);
         public static BinaryExpression AddAssign(Expression left, Expression right, MethodInfo method);
         public static BinaryExpression AddAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion);
         public static BinaryExpression AddAssignChecked(Expression left, Expression right);
         public static BinaryExpression AddAssignChecked(Expression left, Expression right, MethodInfo method);
         public static BinaryExpression AddAssignChecked(Expression left, Expression right, MethodInfo method, LambdaExpression conversion);
         public static BinaryExpression AddChecked(Expression left, Expression right);
         public static BinaryExpression AddChecked(Expression left, Expression right, MethodInfo method);
         public static BinaryExpression And(Expression left, Expression right);
         public static BinaryExpression And(Expression left, Expression right, MethodInfo method);
         public static BinaryExpression AndAlso(Expression left, Expression right);
         public static BinaryExpression AndAlso(Expression left, Expression right, MethodInfo method);
         public static BinaryExpression AndAssign(Expression left, Expression right);
         public static BinaryExpression AndAssign(Expression left, Expression right, MethodInfo method);
         public static BinaryExpression AndAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion);
         public static IndexExpression ArrayAccess(Expression array, params Expression[] indexes);
         public static IndexExpression ArrayAccess(Expression array, IEnumerable<Expression> indexes);
         public static BinaryExpression ArrayIndex(Expression array, Expression index);
         public static MethodCallExpression ArrayIndex(Expression array, params Expression[] indexes);
         public static MethodCallExpression ArrayIndex(Expression array, IEnumerable<Expression> indexes);
         public static UnaryExpression ArrayLength(Expression array);
         public static BinaryExpression Assign(Expression left, Expression right);
         public static MemberAssignment Bind(MemberInfo member, Expression expression);
         public static MemberAssignment Bind(MethodInfo propertyAccessor, Expression expression);
         public static BlockExpression Block(Expression arg0, Expression arg1);
         public static BlockExpression Block(Expression arg0, Expression arg1, Expression arg2);
         public static BlockExpression Block(Expression arg0, Expression arg1, Expression arg2, Expression arg3);
         public static BlockExpression Block(Expression arg0, Expression arg1, Expression arg2, Expression arg3, Expression arg4);
         public static BlockExpression Block(params Expression[] expressions);
         public static BlockExpression Block(IEnumerable<Expression> expressions);
         public static BlockExpression Block(IEnumerable<ParameterExpression> variables, params Expression[] expressions);
         public static BlockExpression Block(IEnumerable<ParameterExpression> variables, IEnumerable<Expression> expressions);
         public static BlockExpression Block(Type type, params Expression[] expressions);
         public static BlockExpression Block(Type type, IEnumerable<Expression> expressions);
         public static BlockExpression Block(Type type, IEnumerable<ParameterExpression> variables, params Expression[] expressions);
         public static BlockExpression Block(Type type, IEnumerable<ParameterExpression> variables, IEnumerable<Expression> expressions);
         public static GotoExpression Break(LabelTarget target);
         public static GotoExpression Break(LabelTarget target, Expression value);
         public static GotoExpression Break(LabelTarget target, Expression value, Type type);
         public static GotoExpression Break(LabelTarget target, Type type);
         public static MethodCallExpression Call(Expression instance, MethodInfo method);
         public static MethodCallExpression Call(Expression instance, MethodInfo method, Expression arg0, Expression arg1);
         public static MethodCallExpression Call(Expression instance, MethodInfo method, Expression arg0, Expression arg1, Expression arg2);
         public static MethodCallExpression Call(Expression instance, MethodInfo method, params Expression[] arguments);
         public static MethodCallExpression Call(Expression instance, MethodInfo method, IEnumerable<Expression> arguments);
         public static MethodCallExpression Call(Expression instance, string methodName, Type[] typeArguments, params Expression[] arguments);
         public static MethodCallExpression Call(MethodInfo method, Expression arg0);
         public static MethodCallExpression Call(MethodInfo method, Expression arg0, Expression arg1);
         public static MethodCallExpression Call(MethodInfo method, Expression arg0, Expression arg1, Expression arg2);
         public static MethodCallExpression Call(MethodInfo method, Expression arg0, Expression arg1, Expression arg2, Expression arg3);
         public static MethodCallExpression Call(MethodInfo method, Expression arg0, Expression arg1, Expression arg2, Expression arg3, Expression arg4);
         public static MethodCallExpression Call(MethodInfo method, params Expression[] arguments);
         public static MethodCallExpression Call(MethodInfo method, IEnumerable<Expression> arguments);
         public static MethodCallExpression Call(Type type, string methodName, Type[] typeArguments, params Expression[] arguments);
         public static CatchBlock Catch(ParameterExpression variable, Expression body);
         public static CatchBlock Catch(ParameterExpression variable, Expression body, Expression filter);
         public static CatchBlock Catch(Type type, Expression body);
         public static CatchBlock Catch(Type type, Expression body, Expression filter);
         public static DebugInfoExpression ClearDebugInfo(SymbolDocumentInfo document);
         public static BinaryExpression Coalesce(Expression left, Expression right);
         public static BinaryExpression Coalesce(Expression left, Expression right, LambdaExpression conversion);
         public static ConditionalExpression Condition(Expression test, Expression ifTrue, Expression ifFalse);
         public static ConditionalExpression Condition(Expression test, Expression ifTrue, Expression ifFalse, Type type);
         public static ConstantExpression Constant(object value);
         public static ConstantExpression Constant(object value, Type type);
         public static GotoExpression Continue(LabelTarget target);
         public static GotoExpression Continue(LabelTarget target, Type type);
         public static UnaryExpression Convert(Expression expression, Type type);
         public static UnaryExpression Convert(Expression expression, Type type, MethodInfo method);
         public static UnaryExpression ConvertChecked(Expression expression, Type type);
         public static UnaryExpression ConvertChecked(Expression expression, Type type, MethodInfo method);
         public static DebugInfoExpression DebugInfo(SymbolDocumentInfo document, int startLine, int startColumn, int endLine, int endColumn);
         public static UnaryExpression Decrement(Expression expression);
         public static UnaryExpression Decrement(Expression expression, MethodInfo method);
         public static DefaultExpression Default(Type type);
         public static BinaryExpression Divide(Expression left, Expression right);
         public static BinaryExpression Divide(Expression left, Expression right, MethodInfo method);
         public static BinaryExpression DivideAssign(Expression left, Expression right);
         public static BinaryExpression DivideAssign(Expression left, Expression right, MethodInfo method);
         public static BinaryExpression DivideAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion);
         public static ElementInit ElementInit(MethodInfo addMethod, params Expression[] arguments);
         public static ElementInit ElementInit(MethodInfo addMethod, IEnumerable<Expression> arguments);
         public static DefaultExpression Empty();
         public static BinaryExpression Equal(Expression left, Expression right);
         public static BinaryExpression Equal(Expression left, Expression right, bool liftToNull, MethodInfo method);
         public static BinaryExpression ExclusiveOr(Expression left, Expression right);
         public static BinaryExpression ExclusiveOr(Expression left, Expression right, MethodInfo method);
         public static BinaryExpression ExclusiveOrAssign(Expression left, Expression right);
         public static BinaryExpression ExclusiveOrAssign(Expression left, Expression right, MethodInfo method);
         public static BinaryExpression ExclusiveOrAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion);
         public static MemberExpression Field(Expression expression, FieldInfo field);
         public static MemberExpression Field(Expression expression, string fieldName);
         public static MemberExpression Field(Expression expression, Type type, string fieldName);
         public static Type GetActionType(params Type[] typeArgs);
         public static Type GetDelegateType(params Type[] typeArgs);
         public static Type GetFuncType(params Type[] typeArgs);
         public static GotoExpression Goto(LabelTarget target);
         public static GotoExpression Goto(LabelTarget target, Expression value);
         public static GotoExpression Goto(LabelTarget target, Expression value, Type type);
         public static GotoExpression Goto(LabelTarget target, Type type);
         public static BinaryExpression GreaterThan(Expression left, Expression right);
         public static BinaryExpression GreaterThan(Expression left, Expression right, bool liftToNull, MethodInfo method);
         public static BinaryExpression GreaterThanOrEqual(Expression left, Expression right);
         public static BinaryExpression GreaterThanOrEqual(Expression left, Expression right, bool liftToNull, MethodInfo method);
         public static ConditionalExpression IfThen(Expression test, Expression ifTrue);
         public static ConditionalExpression IfThenElse(Expression test, Expression ifTrue, Expression ifFalse);
         public static UnaryExpression Increment(Expression expression);
         public static UnaryExpression Increment(Expression expression, MethodInfo method);
         public static InvocationExpression Invoke(Expression expression, params Expression[] arguments);
         public static InvocationExpression Invoke(Expression expression, IEnumerable<Expression> arguments);
         public static UnaryExpression IsFalse(Expression expression);
         public static UnaryExpression IsFalse(Expression expression, MethodInfo method);
         public static UnaryExpression IsTrue(Expression expression);
         public static UnaryExpression IsTrue(Expression expression, MethodInfo method);
         public static LabelTarget Label();
         public static LabelExpression Label(LabelTarget target);
         public static LabelExpression Label(LabelTarget target, Expression defaultValue);
         public static LabelTarget Label(string name);
         public static LabelTarget Label(Type type);
         public static LabelTarget Label(Type type, string name);
         public static Expression<TDelegate> Lambda<TDelegate>(Expression body, params ParameterExpression[] parameters);
         public static Expression<TDelegate> Lambda<TDelegate>(Expression body, bool tailCall, params ParameterExpression[] parameters);
         public static Expression<TDelegate> Lambda<TDelegate>(Expression body, IEnumerable<ParameterExpression> parameters);
         public static Expression<TDelegate> Lambda<TDelegate>(Expression body, string name, IEnumerable<ParameterExpression> parameters);
         public static Expression<TDelegate> Lambda<TDelegate>(Expression body, bool tailCall, IEnumerable<ParameterExpression> parameters);
         public static Expression<TDelegate> Lambda<TDelegate>(Expression body, string name, bool tailCall, IEnumerable<ParameterExpression> parameters);
         public static LambdaExpression Lambda(Expression body, bool tailCall, IEnumerable<ParameterExpression> parameters);
         public static LambdaExpression Lambda(Expression body, bool tailCall, params ParameterExpression[] parameters);
         public static LambdaExpression Lambda(Expression body, IEnumerable<ParameterExpression> parameters);
         public static LambdaExpression Lambda(Expression body, params ParameterExpression[] parameters);
         public static LambdaExpression Lambda(Expression body, string name, bool tailCall, IEnumerable<ParameterExpression> parameters);
         public static LambdaExpression Lambda(Expression body, string name, IEnumerable<ParameterExpression> parameters);
         public static LambdaExpression Lambda(Type delegateType, Expression body, bool tailCall, IEnumerable<ParameterExpression> parameters);
         public static LambdaExpression Lambda(Type delegateType, Expression body, bool tailCall, params ParameterExpression[] parameters);
         public static LambdaExpression Lambda(Type delegateType, Expression body, IEnumerable<ParameterExpression> parameters);
         public static LambdaExpression Lambda(Type delegateType, Expression body, params ParameterExpression[] parameters);
         public static LambdaExpression Lambda(Type delegateType, Expression body, string name, bool tailCall, IEnumerable<ParameterExpression> parameters);
         public static LambdaExpression Lambda(Type delegateType, Expression body, string name, IEnumerable<ParameterExpression> parameters);
         public static BinaryExpression LeftShift(Expression left, Expression right);
         public static BinaryExpression LeftShift(Expression left, Expression right, MethodInfo method);
         public static BinaryExpression LeftShiftAssign(Expression left, Expression right);
         public static BinaryExpression LeftShiftAssign(Expression left, Expression right, MethodInfo method);
         public static BinaryExpression LeftShiftAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion);
         public static BinaryExpression LessThan(Expression left, Expression right);
         public static BinaryExpression LessThan(Expression left, Expression right, bool liftToNull, MethodInfo method);
         public static BinaryExpression LessThanOrEqual(Expression left, Expression right);
         public static BinaryExpression LessThanOrEqual(Expression left, Expression right, bool liftToNull, MethodInfo method);
         public static MemberListBinding ListBind(MemberInfo member, params ElementInit[] initializers);
         public static MemberListBinding ListBind(MemberInfo member, IEnumerable<ElementInit> initializers);
         public static MemberListBinding ListBind(MethodInfo propertyAccessor, params ElementInit[] initializers);
         public static MemberListBinding ListBind(MethodInfo propertyAccessor, IEnumerable<ElementInit> initializers);
         public static ListInitExpression ListInit(NewExpression newExpression, params ElementInit[] initializers);
         public static ListInitExpression ListInit(NewExpression newExpression, params Expression[] initializers);
         public static ListInitExpression ListInit(NewExpression newExpression, IEnumerable<Expression> initializers);
         public static ListInitExpression ListInit(NewExpression newExpression, IEnumerable<ElementInit> initializers);
         public static ListInitExpression ListInit(NewExpression newExpression, MethodInfo addMethod, params Expression[] initializers);
         public static ListInitExpression ListInit(NewExpression newExpression, MethodInfo addMethod, IEnumerable<Expression> initializers);
         public static LoopExpression Loop(Expression body);
         public static LoopExpression Loop(Expression body, LabelTarget @break);
         public static LoopExpression Loop(Expression body, LabelTarget @break, LabelTarget @continue);
         public static BinaryExpression MakeBinary(ExpressionType binaryType, Expression left, Expression right);
         public static BinaryExpression MakeBinary(ExpressionType binaryType, Expression left, Expression right, bool liftToNull, MethodInfo method);
         public static BinaryExpression MakeBinary(ExpressionType binaryType, Expression left, Expression right, bool liftToNull, MethodInfo method, LambdaExpression conversion);
         public static CatchBlock MakeCatchBlock(Type type, ParameterExpression variable, Expression body, Expression filter);
         public static GotoExpression MakeGoto(GotoExpressionKind kind, LabelTarget target, Expression value, Type type);
         public static IndexExpression MakeIndex(Expression instance, PropertyInfo indexer, IEnumerable<Expression> arguments);
         public static MemberExpression MakeMemberAccess(Expression expression, MemberInfo member);
         public static TryExpression MakeTry(Type type, Expression body, Expression @finally, Expression fault, IEnumerable<CatchBlock> handlers);
         public static UnaryExpression MakeUnary(ExpressionType unaryType, Expression operand, Type type);
         public static UnaryExpression MakeUnary(ExpressionType unaryType, Expression operand, Type type, MethodInfo method);
         public static MemberMemberBinding MemberBind(MemberInfo member, IEnumerable<MemberBinding> bindings);
         public static MemberMemberBinding MemberBind(MemberInfo member, params MemberBinding[] bindings);
         public static MemberMemberBinding MemberBind(MethodInfo propertyAccessor, IEnumerable<MemberBinding> bindings);
         public static MemberMemberBinding MemberBind(MethodInfo propertyAccessor, params MemberBinding[] bindings);
         public static MemberInitExpression MemberInit(NewExpression newExpression, IEnumerable<MemberBinding> bindings);
         public static MemberInitExpression MemberInit(NewExpression newExpression, params MemberBinding[] bindings);
         public static BinaryExpression Modulo(Expression left, Expression right);
         public static BinaryExpression Modulo(Expression left, Expression right, MethodInfo method);
         public static BinaryExpression ModuloAssign(Expression left, Expression right);
         public static BinaryExpression ModuloAssign(Expression left, Expression right, MethodInfo method);
         public static BinaryExpression ModuloAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion);
         public static BinaryExpression Multiply(Expression left, Expression right);
         public static BinaryExpression Multiply(Expression left, Expression right, MethodInfo method);
         public static BinaryExpression MultiplyAssign(Expression left, Expression right);
         public static BinaryExpression MultiplyAssign(Expression left, Expression right, MethodInfo method);
         public static BinaryExpression MultiplyAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion);
         public static BinaryExpression MultiplyAssignChecked(Expression left, Expression right);
         public static BinaryExpression MultiplyAssignChecked(Expression left, Expression right, MethodInfo method);
         public static BinaryExpression MultiplyAssignChecked(Expression left, Expression right, MethodInfo method, LambdaExpression conversion);
         public static BinaryExpression MultiplyChecked(Expression left, Expression right);
         public static BinaryExpression MultiplyChecked(Expression left, Expression right, MethodInfo method);
         public static UnaryExpression Negate(Expression expression);
         public static UnaryExpression Negate(Expression expression, MethodInfo method);
         public static UnaryExpression NegateChecked(Expression expression);
         public static UnaryExpression NegateChecked(Expression expression, MethodInfo method);
         public static NewExpression New(ConstructorInfo constructor);
         public static NewExpression New(ConstructorInfo constructor, params Expression[] arguments);
         public static NewExpression New(ConstructorInfo constructor, IEnumerable<Expression> arguments);
         public static NewExpression New(ConstructorInfo constructor, IEnumerable<Expression> arguments, params MemberInfo[] members);
         public static NewExpression New(ConstructorInfo constructor, IEnumerable<Expression> arguments, IEnumerable<MemberInfo> members);
         public static NewExpression New(Type type);
         public static NewArrayExpression NewArrayBounds(Type type, params Expression[] bounds);
         public static NewArrayExpression NewArrayBounds(Type type, IEnumerable<Expression> bounds);
         public static NewArrayExpression NewArrayInit(Type type, params Expression[] initializers);
         public static NewArrayExpression NewArrayInit(Type type, IEnumerable<Expression> initializers);
         public static UnaryExpression Not(Expression expression);
         public static UnaryExpression Not(Expression expression, MethodInfo method);
         public static BinaryExpression NotEqual(Expression left, Expression right);
         public static BinaryExpression NotEqual(Expression left, Expression right, bool liftToNull, MethodInfo method);
         public static UnaryExpression OnesComplement(Expression expression);
         public static UnaryExpression OnesComplement(Expression expression, MethodInfo method);
         public static BinaryExpression Or(Expression left, Expression right);
         public static BinaryExpression Or(Expression left, Expression right, MethodInfo method);
         public static BinaryExpression OrAssign(Expression left, Expression right);
         public static BinaryExpression OrAssign(Expression left, Expression right, MethodInfo method);
         public static BinaryExpression OrAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion);
         public static BinaryExpression OrElse(Expression left, Expression right);
         public static BinaryExpression OrElse(Expression left, Expression right, MethodInfo method);
         public static ParameterExpression Parameter(Type type);
         public static ParameterExpression Parameter(Type type, string name);
         public static UnaryExpression PostDecrementAssign(Expression expression);
         public static UnaryExpression PostDecrementAssign(Expression expression, MethodInfo method);
         public static UnaryExpression PostIncrementAssign(Expression expression);
         public static UnaryExpression PostIncrementAssign(Expression expression, MethodInfo method);
         public static BinaryExpression Power(Expression left, Expression right);
         public static BinaryExpression Power(Expression left, Expression right, MethodInfo method);
         public static BinaryExpression PowerAssign(Expression left, Expression right);
         public static BinaryExpression PowerAssign(Expression left, Expression right, MethodInfo method);
         public static BinaryExpression PowerAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion);
         public static UnaryExpression PreDecrementAssign(Expression expression);
         public static UnaryExpression PreDecrementAssign(Expression expression, MethodInfo method);
         public static UnaryExpression PreIncrementAssign(Expression expression);
         public static UnaryExpression PreIncrementAssign(Expression expression, MethodInfo method);
         public static MemberExpression Property(Expression expression, MethodInfo propertyAccessor);
         public static MemberExpression Property(Expression expression, PropertyInfo property);
         public static IndexExpression Property(Expression instance, PropertyInfo indexer, params Expression[] arguments);
         public static IndexExpression Property(Expression instance, PropertyInfo indexer, IEnumerable<Expression> arguments);
         public static MemberExpression Property(Expression expression, string propertyName);
         public static IndexExpression Property(Expression instance, string propertyName, params Expression[] arguments);
         public static MemberExpression Property(Expression expression, Type type, string propertyName);
         public static MemberExpression PropertyOrField(Expression expression, string propertyOrFieldName);
         public static UnaryExpression Quote(Expression expression);
         public virtual Expression Reduce();
         public Expression ReduceAndCheck();
         public Expression ReduceExtensions();
         public static BinaryExpression ReferenceEqual(Expression left, Expression right);
         public static BinaryExpression ReferenceNotEqual(Expression left, Expression right);
         public static UnaryExpression Rethrow();
         public static UnaryExpression Rethrow(Type type);
         public static GotoExpression Return(LabelTarget target);
         public static GotoExpression Return(LabelTarget target, Expression value);
         public static GotoExpression Return(LabelTarget target, Expression value, Type type);
         public static GotoExpression Return(LabelTarget target, Type type);
         public static BinaryExpression RightShift(Expression left, Expression right);
         public static BinaryExpression RightShift(Expression left, Expression right, MethodInfo method);
         public static BinaryExpression RightShiftAssign(Expression left, Expression right);
         public static BinaryExpression RightShiftAssign(Expression left, Expression right, MethodInfo method);
         public static BinaryExpression RightShiftAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion);
         public static RuntimeVariablesExpression RuntimeVariables(IEnumerable<ParameterExpression> variables);
         public static RuntimeVariablesExpression RuntimeVariables(params ParameterExpression[] variables);
         public static BinaryExpression Subtract(Expression left, Expression right);
         public static BinaryExpression Subtract(Expression left, Expression right, MethodInfo method);
         public static BinaryExpression SubtractAssign(Expression left, Expression right);
         public static BinaryExpression SubtractAssign(Expression left, Expression right, MethodInfo method);
         public static BinaryExpression SubtractAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion);
         public static BinaryExpression SubtractAssignChecked(Expression left, Expression right);
         public static BinaryExpression SubtractAssignChecked(Expression left, Expression right, MethodInfo method);
         public static BinaryExpression SubtractAssignChecked(Expression left, Expression right, MethodInfo method, LambdaExpression conversion);
         public static BinaryExpression SubtractChecked(Expression left, Expression right);
         public static BinaryExpression SubtractChecked(Expression left, Expression right, MethodInfo method);
         public static SwitchExpression Switch(Expression switchValue, Expression defaultBody, MethodInfo comparison, IEnumerable<SwitchCase> cases);
         public static SwitchExpression Switch(Expression switchValue, Expression defaultBody, MethodInfo comparison, params SwitchCase[] cases);
         public static SwitchExpression Switch(Expression switchValue, Expression defaultBody, params SwitchCase[] cases);
         public static SwitchExpression Switch(Expression switchValue, params SwitchCase[] cases);
         public static SwitchExpression Switch(Type type, Expression switchValue, Expression defaultBody, MethodInfo comparison, IEnumerable<SwitchCase> cases);
         public static SwitchExpression Switch(Type type, Expression switchValue, Expression defaultBody, MethodInfo comparison, params SwitchCase[] cases);
         public static SwitchCase SwitchCase(Expression body, params Expression[] testValues);
         public static SwitchCase SwitchCase(Expression body, IEnumerable<Expression> testValues);
         public static SymbolDocumentInfo SymbolDocument(string fileName);
         public static SymbolDocumentInfo SymbolDocument(string fileName, Guid language);
         public static SymbolDocumentInfo SymbolDocument(string fileName, Guid language, Guid languageVendor);
         public static SymbolDocumentInfo SymbolDocument(string fileName, Guid language, Guid languageVendor, Guid documentType);
         public static UnaryExpression Throw(Expression value);
         public static UnaryExpression Throw(Expression value, Type type);
         public override string ToString();
         public static TryExpression TryCatch(Expression body, params CatchBlock[] handlers);
         public static TryExpression TryCatchFinally(Expression body, Expression @finally, params CatchBlock[] handlers);
         public static TryExpression TryFault(Expression body, Expression fault);
         public static TryExpression TryFinally(Expression body, Expression @finally);
         public static bool TryGetActionType(Type[] typeArgs, out Type actionType);
         public static bool TryGetFuncType(Type[] typeArgs, out Type funcType);
         public static UnaryExpression TypeAs(Expression expression, Type type);
         public static TypeBinaryExpression TypeEqual(Expression expression, Type type);
         public static TypeBinaryExpression TypeIs(Expression expression, Type type);
         public static UnaryExpression UnaryPlus(Expression expression);
         public static UnaryExpression UnaryPlus(Expression expression, MethodInfo method);
         public static UnaryExpression Unbox(Expression expression, Type type);
         public static ParameterExpression Variable(Type type);
         public static ParameterExpression Variable(Type type, string name);
         protected internal virtual Expression VisitChildren(ExpressionVisitor visitor);
     }
     public sealed class Expression<TDelegate> : LambdaExpression {
         public new TDelegate Compile();
         public Expression<TDelegate> Update(Expression body, IEnumerable<ParameterExpression> parameters);
     }
     public enum ExpressionType {
         Add = 0,
         AddAssign = 63,
         AddAssignChecked = 74,
         AddChecked = 1,
         And = 2,
         AndAlso = 3,
         AndAssign = 64,
         ArrayIndex = 5,
         ArrayLength = 4,
         Assign = 46,
         Block = 47,
         Call = 6,
         Coalesce = 7,
         Conditional = 8,
         Constant = 9,
         Convert = 10,
         ConvertChecked = 11,
         DebugInfo = 48,
         Decrement = 49,
         Default = 51,
         Divide = 12,
         DivideAssign = 65,
         Dynamic = 50,
         Equal = 13,
         ExclusiveOr = 14,
         ExclusiveOrAssign = 66,
         Extension = 52,
         Goto = 53,
         GreaterThan = 15,
         GreaterThanOrEqual = 16,
         Increment = 54,
         Index = 55,
         Invoke = 17,
         IsFalse = 84,
         IsTrue = 83,
         Label = 56,
         Lambda = 18,
         LeftShift = 19,
         LeftShiftAssign = 67,
         LessThan = 20,
         LessThanOrEqual = 21,
         ListInit = 22,
         Loop = 58,
         MemberAccess = 23,
         MemberInit = 24,
         Modulo = 25,
         ModuloAssign = 68,
         Multiply = 26,
         MultiplyAssign = 69,
         MultiplyAssignChecked = 75,
         MultiplyChecked = 27,
         Negate = 28,
         NegateChecked = 30,
         New = 31,
         NewArrayBounds = 33,
         NewArrayInit = 32,
         Not = 34,
         NotEqual = 35,
         OnesComplement = 82,
         Or = 36,
         OrAssign = 70,
         OrElse = 37,
         Parameter = 38,
         PostDecrementAssign = 80,
         PostIncrementAssign = 79,
         Power = 39,
         PowerAssign = 71,
         PreDecrementAssign = 78,
         PreIncrementAssign = 77,
         Quote = 40,
         RightShift = 41,
         RightShiftAssign = 72,
         RuntimeVariables = 57,
         Subtract = 42,
         SubtractAssign = 73,
         SubtractAssignChecked = 76,
         SubtractChecked = 43,
         Switch = 59,
         Throw = 60,
         Try = 61,
         TypeAs = 44,
         TypeEqual = 81,
         TypeIs = 45,
         UnaryPlus = 29,
         Unbox = 62,
     }
     public abstract class ExpressionVisitor {
         protected ExpressionVisitor();
         public static ReadOnlyCollection<T> Visit<T>(ReadOnlyCollection<T> nodes, Func<T, T> elementVisitor);
         public virtual Expression Visit(Expression node);
         public ReadOnlyCollection<Expression