# System

``` diff
 namespace System {
-    public class ArgumentException : SystemException, ISerializable
+    public class ArgumentException : SystemException
-    public class ArgumentOutOfRangeException : ArgumentException, ISerializable
+    public class ArgumentOutOfRangeException : ArgumentException
-    public struct ArraySegment<T> : ICollection<T>, IEnumerable, IEnumerable<T>, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T> {
+    public readonly struct ArraySegment<T> : ICollection<T>, IEnumerable, IEnumerable<T>, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T> {
-        void System.Collections.Generic.ICollection<T>.CopyTo(T[] array, int arrayIndex);

     }
     public static class BitConverter {
+        public static bool ToBoolean(ReadOnlySpan<byte> value);
+        public static char ToChar(ReadOnlySpan<byte> value);
+        public static double ToDouble(ReadOnlySpan<byte> value);
+        public static short ToInt16(ReadOnlySpan<byte> value);
+        public static int ToInt32(ReadOnlySpan<byte> value);
+        public static long ToInt64(ReadOnlySpan<byte> value);
+        public static float ToSingle(ReadOnlySpan<byte> value);
+        public static ushort ToUInt16(ReadOnlySpan<byte> value);
+        public static uint ToUInt32(ReadOnlySpan<byte> value);
+        public static ulong ToUInt64(ReadOnlySpan<byte> value);
+        public static bool TryWriteBytes(Span<byte> destination, bool value);
+        public static bool TryWriteBytes(Span<byte> destination, char value);
+        public static bool TryWriteBytes(Span<byte> destination, double value);
+        public static bool TryWriteBytes(Span<byte> destination, short value);
+        public static bool TryWriteBytes(Span<byte> destination, int value);
+        public static bool TryWriteBytes(Span<byte> destination, long value);
+        public static bool TryWriteBytes(Span<byte> destination, float value);
+        public static bool TryWriteBytes(Span<byte> destination, ushort value);
+        public static bool TryWriteBytes(Span<byte> destination, uint value);
+        public static bool TryWriteBytes(Span<byte> destination, ulong value);
     }
     public struct Boolean : IComparable, IComparable<bool>, IConvertible, IEquatable<bool> {
+        public static Boolean Parse(ReadOnlySpan<char> value);
+        public Boolean TryFormat(Span<char> destination, out int charsWritten);
+        public static Boolean TryParse(ReadOnlySpan<char> value, out Boolean result);
     }
     public struct Byte : IComparable, IComparable<byte>, IConvertible, IEquatable<byte>, IFormattable {
+        public static Byte Parse(ReadOnlySpan<char> s, NumberStyles style = (NumberStyles)(7), IFormatProvider provider = null);
+        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider provider = null);
+        public static bool TryParse(ReadOnlySpan<char> s, out Byte result);
+        public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out Byte result);
     }
-    public struct ConsoleKeyInfo
+    public readonly struct ConsoleKeyInfo
     public static class Convert {
+        public static string ToBase64String(ReadOnlySpan<byte> bytes, Base64FormattingOptions options = (Base64FormattingOptions)(0));
+        public static bool TryFromBase64Chars(ReadOnlySpan<char> chars, Span<byte> bytes, out int bytesWritten);
+        public static bool TryFromBase64String(string s, Span<byte> bytes, out int bytesWritten);
+        public static bool TryToBase64Chars(ReadOnlySpan<byte> bytes, Span<char> chars, out int charsWritten, Base64FormattingOptions options = (Base64FormattingOptions)(0));
     }
-    public struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable, ISerializable {
+    public readonly struct DateTime : IComparable, IComparable<DateTime>, IConvertible, IEquatable<DateTime>, IFormattable, ISerializable {
+        public static readonly DateTime UnixEpoch;
+        public static DateTime Parse(ReadOnlySpan<char> s, IFormatProvider provider = null, DateTimeStyles styles = (DateTimeStyles)(0));
+        public static DateTime ParseExact(ReadOnlySpan<char> s, ReadOnlySpan<char> format, IFormatProvider provider, DateTimeStyles style = (DateTimeStyles)(0));
+        public static DateTime ParseExact(ReadOnlySpan<char> s, string[] formats, IFormatProvider provider, DateTimeStyles style = (DateTimeStyles)(0));
-        int System.IComparable.CompareTo(object value);

-        TypeCode System.IConvertible.GetTypeCode();

+        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider provider = null);
+        public static bool TryParse(ReadOnlySpan<char> s, out DateTime result);
+        public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider provider, DateTimeStyles styles, out DateTime result);
+        public static bool TryParseExact(ReadOnlySpan<char> s, ReadOnlySpan<char> format, IFormatProvider provider, DateTimeStyles style, out DateTime result);
+        public static bool TryParseExact(ReadOnlySpan<char> s, string[] formats, IFormatProvider provider, DateTimeStyles style, out DateTime result);
     }
     public struct DateTimeOffset : IComparable, IComparable<DateTimeOffset>, IDeserializationCallback, IEquatable<DateTimeOffset>, IFormattable, ISerializable {
+        public static readonly DateTimeOffset UnixEpoch;
+        public static DateTimeOffset Parse(ReadOnlySpan<char> input, IFormatProvider formatProvider = null, DateTimeStyles styles = (DateTimeStyles)(0));
+        public static DateTimeOffset ParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider formatProvider, DateTimeStyles styles = (DateTimeStyles)(0));
+        public static DateTimeOffset ParseExact(ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, DateTimeStyles styles = (DateTimeStyles)(0));
+        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider formatProvider = null);
+        public static bool TryParse(ReadOnlySpan<char> input, out DateTimeOffset result);
+        public static bool TryParse(ReadOnlySpan<char> input, IFormatProvider formatProvider, DateTimeStyles styles, out DateTimeOffset result);
+        public static bool TryParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider formatProvider, DateTimeStyles styles, out DateTimeOffset result);
+        public static bool TryParseExact(ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, DateTimeStyles styles, out DateTimeOffset result);
     }
     public struct Decimal : IComparable, IComparable<decimal>, IConvertible, IDeserializationCallback, IEquatable<decimal>, IFormattable {
+        public static Decimal Parse(ReadOnlySpan<char> s, NumberStyles style = (NumberStyles)(111), IFormatProvider provider = null);
+        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider provider = null);
+        public static bool TryParse(ReadOnlySpan<char> s, out Decimal result);
+        public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out Decimal result);
     }
     public struct Double : IComparable, IComparable<double>, IConvertible, IEquatable<double>, IFormattable {
+        public static bool IsFinite(Double d);
+        public static bool IsNegative(Double d);
+        public static bool IsNormal(Double d);
+        public static bool IsSubnormal(Double d);
+        public static Double Parse(ReadOnlySpan<char> s, NumberStyles style = (NumberStyles)(231), IFormatProvider provider = null);
+        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider provider = null);
+        public static bool TryParse(ReadOnlySpan<char> s, out Double result);
+        public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out Double result);
     }
-    public class DuplicateWaitObjectException : ArgumentException, ISerializable
+    public class DuplicateWaitObjectException : ArgumentException
     public abstract class Enum : ValueType, IComparable, IConvertible, IFormattable {
-        TypeCode System.IConvertible.GetTypeCode();

     }
     public struct Guid : IComparable, IComparable<Guid>, IEquatable<Guid>, IFormattable {
+        public Guid(ReadOnlySpan<byte> b);
+        public static Guid Parse(ReadOnlySpan<char> input);
+        public static Guid ParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format);
+        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>));
+        public static bool TryParse(ReadOnlySpan<char> input, out Guid result);
+        public static bool TryParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, out Guid result);
+        public bool TryWriteBytes(Span<byte> destination);
     }
+    public struct HashCode {
+        public void Add<T>(T value);
+        public void Add<T>(T value, IEqualityComparer<T> comparer);
+        public static int Combine<T1, T2, T3, T4, T5, T6, T7, T8>(T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7, T8 value8);
+        public static int Combine<T1, T2, T3, T4, T5, T6, T7>(T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6, T7 value7);
+        public static int Combine<T1, T2, T3, T4, T5, T6>(T1 value1, T2 value2, T3 value3, T4 value4, T5 value5, T6 value6);
+        public static int Combine<T1, T2, T3, T4, T5>(T1 value1, T2 value2, T3 value3, T4 value4, T5 value5);
+        public static int Combine<T1, T2, T3, T4>(T1 value1, T2 value2, T3 value3, T4 value4);
+        public static int Combine<T1, T2, T3>(T1 value1, T2 value2, T3 value3);
+        public static int Combine<T1, T2>(T1 value1, T2 value2);
+        public static int Combine<T1>(T1 value1);
+        public override bool Equals(object obj);
+        public override int GetHashCode();
+        public int ToHashCode();
+    }
     public struct Int16 : IComparable, IComparable<short>, IConvertible, IEquatable<short>, IFormattable {
+        public static Int16 Parse(ReadOnlySpan<char> s, NumberStyles style = (NumberStyles)(7), IFormatProvider provider = null);
+        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider provider = null);
+        public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out Int16 result);
+        public static bool TryParse(ReadOnlySpan<char> s, out Int16 result);
     }
     public struct Int32 : IComparable, IComparable<int>, IConvertible, IEquatable<int>, IFormattable {
+        public static Int32 Parse(ReadOnlySpan<char> s, NumberStyles style = (NumberStyles)(7), IFormatProvider provider = null);
+        public bool TryFormat(Span<char> destination, out Int32 charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider provider = null);
+        public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out Int32 result);
+        public static bool TryParse(ReadOnlySpan<char> s, out Int32 result);
     }
     public struct Int64 : IComparable, IComparable<long>, IConvertible, IEquatable<long>, IFormattable {
+        public static Int64 Parse(ReadOnlySpan<char> s, NumberStyles style = (NumberStyles)(7), IFormatProvider provider = null);
+        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider provider = null);
+        public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out Int64 result);
+        public static bool TryParse(ReadOnlySpan<char> s, out Int64 result);
     }
     public static class Math {
+        public static double Acosh(double d);
+        public static double Asinh(double d);
+        public static double Atanh(double d);
+        public static double Cbrt(double d);
     }
     public static class MathF {
+        public static float Acosh(float x);
+        public static float Asinh(float x);
+        public static float Atanh(float x);
+        public static float Cbrt(float x);
     }
+    public readonly struct Memory<T> {
+        public Memory(T[] array);
+        public Memory(T[] array, int start, int length);
+        public static Memory<T> Empty { get; }
+        public bool IsEmpty { get; }
+        public int Length { get; }
+        public Span<T> Span { get; }
+        public void CopyTo(Memory<T> destination);
+        public bool Equals(Memory<T> other);
+        public override bool Equals(object obj);
+        public override int GetHashCode();
+        public static implicit operator Memory<T> (ArraySegment<T> segment);
+        public static implicit operator ReadOnlyMemory<T> (Memory<T> memory);
+        public static implicit operator Memory<T> (T[] array);
+        public MemoryHandle Pin();
+        public Memory<T> Slice(int start);
+        public Memory<T> Slice(int start, int length);
+        public T[] ToArray();
+        public override string ToString();
+        public bool TryCopyTo(Memory<T> destination);
+    }
+    public static class MemoryExtensions {
+        public static ReadOnlyMemory<char> AsMemory(this string text);
+        public static ReadOnlyMemory<char> AsMemory(this string text, int start);
+        public static ReadOnlyMemory<char> AsMemory(this string text, int start, int length);
+        public static Memory<T> AsMemory<T>(this ArraySegment<T> segment);
+        public static Memory<T> AsMemory<T>(this ArraySegment<T> segment, int start);
+        public static Memory<T> AsMemory<T>(this ArraySegment<T> segment, int start, int length);
+        public static Memory<T> AsMemory<T>(this T[] array);
+        public static Memory<T> AsMemory<T>(this T[] array, int start);
+        public static Memory<T> AsMemory<T>(this T[] array, int start, int length);
+        public static ReadOnlySpan<char> AsSpan(this string text);
+        public static ReadOnlySpan<char> AsSpan(this string text, int start);
+        public static ReadOnlySpan<char> AsSpan(this string text, int start, int length);
+        public static Span<T> AsSpan<T>(this ArraySegment<T> segment);
+        public static Span<T> AsSpan<T>(this ArraySegment<T> segment, int start);
+        public static Span<T> AsSpan<T>(this ArraySegment<T> segment, int start, int length);
+        public static Span<T> AsSpan<T>(this T[] array);
+        public static Span<T> AsSpan<T>(this T[] array, int start);
+        public static Span<T> AsSpan<T>(this T[] array, int start, int length);
+        public static int BinarySearch<T, TComparable>(this ReadOnlySpan<T> span, TComparable comparable) where TComparable : IComparable<T>;
+        public static int BinarySearch<T, TComparable>(this Span<T> span, TComparable comparable) where TComparable : IComparable<T>;
+        public static int BinarySearch<T, TComparer>(this ReadOnlySpan<T> span, T value, TComparer comparer) where TComparer : IComparer<T>;
+        public static int BinarySearch<T, TComparer>(this Span<T> span, T value, TComparer comparer) where TComparer : IComparer<T>;
+        public static int BinarySearch<T>(this ReadOnlySpan<T> span, IComparable<T> comparable);
+        public static int BinarySearch<T>(this Span<T> span, IComparable<T> comparable);
+        public static int CompareTo(this ReadOnlySpan<char> span, ReadOnlySpan<char> other, StringComparison comparisonType);
+        public static bool Contains(this ReadOnlySpan<char> span, ReadOnlySpan<char> value, StringComparison comparisonType);
+        public static void CopyTo<T>(this T[] source, Memory<T> destination);
+        public static void CopyTo<T>(this T[] source, Span<T> destination);
+        public static bool EndsWith(this ReadOnlySpan<char> span, ReadOnlySpan<char> value, StringComparison comparisonType);
+        public static bool EndsWith<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> value) where T : IEquatable<T>;
+        public static bool EndsWith<T>(this Span<T> span, ReadOnlySpan<T> value) where T : IEquatable<T>;
+        public static bool Equals(this ReadOnlySpan<char> span, ReadOnlySpan<char> other, StringComparison comparisonType);
+        public static int IndexOf(this ReadOnlySpan<char> span, ReadOnlySpan<char> value, StringComparison comparisonType);
+        public static int IndexOf<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> value) where T : IEquatable<T>;
+        public static int IndexOf<T>(this ReadOnlySpan<T> span, T value) where T : IEquatable<T>;
+        public static int IndexOf<T>(this Span<T> span, ReadOnlySpan<T> value) where T : IEquatable<T>;
+        public static int IndexOf<T>(this Span<T> span, T value) where T : IEquatable<T>;
+        public static int IndexOfAny<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> values) where T : IEquatable<T>;
+        public static int IndexOfAny<T>(this ReadOnlySpan<T> span, T value0, T value1) where T : IEquatable<T>;
+        public static int IndexOfAny<T>(this ReadOnlySpan<T> span, T value0, T value1, T value2) where T : IEquatable<T>;
+        public static int IndexOfAny<T>(this Span<T> span, ReadOnlySpan<T> values) where T : IEquatable<T>;
+        public static int IndexOfAny<T>(this Span<T> span, T value0, T value1) where T : IEquatable<T>;
+        public static int IndexOfAny<T>(this Span<T> span, T value0, T value1, T value2) where T : IEquatable<T>;
+        public static bool IsWhiteSpace(this ReadOnlySpan<char> span);
+        public static int LastIndexOf<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> value) where T : IEquatable<T>;
+        public static int LastIndexOf<T>(this ReadOnlySpan<T> span, T value) where T : IEquatable<T>;
+        public static int LastIndexOf<T>(this Span<T> span, ReadOnlySpan<T> value) where T : IEquatable<T>;
+        public static int LastIndexOf<T>(this Span<T> span, T value) where T : IEquatable<T>;
+        public static int LastIndexOfAny<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> values) where T : IEquatable<T>;
+        public static int LastIndexOfAny<T>(this ReadOnlySpan<T> span, T value0, T value1) where T : IEquatable<T>;
+        public static int LastIndexOfAny<T>(this ReadOnlySpan<T> span, T value0, T value1, T value2) where T : IEquatable<T>;
+        public static int LastIndexOfAny<T>(this Span<T> span, ReadOnlySpan<T> values) where T : IEquatable<T>;
+        public static int LastIndexOfAny<T>(this Span<T> span, T value0, T value1) where T : IEquatable<T>;
+        public static int LastIndexOfAny<T>(this Span<T> span, T value0, T value1, T value2) where T : IEquatable<T>;
+        public static bool Overlaps<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> other);
+        public static bool Overlaps<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> other, out int elementOffset);
+        public static bool Overlaps<T>(this Span<T> span, ReadOnlySpan<T> other);
+        public static bool Overlaps<T>(this Span<T> span, ReadOnlySpan<T> other, out int elementOffset);
+        public static void Reverse<T>(this Span<T> span);
+        public static int SequenceCompareTo<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> other) where T : IComparable<T>;
+        public static int SequenceCompareTo<T>(this Span<T> span, ReadOnlySpan<T> other) where T : IComparable<T>;
+        public static bool SequenceEqual<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> other) where T : IEquatable<T>;
+        public static bool SequenceEqual<T>(this Span<T> span, ReadOnlySpan<T> other) where T : IEquatable<T>;
+        public static bool StartsWith(this ReadOnlySpan<char> span, ReadOnlySpan<char> value, StringComparison comparisonType);
+        public static bool StartsWith<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> value) where T : IEquatable<T>;
+        public static bool StartsWith<T>(this Span<T> span, ReadOnlySpan<T> value) where T : IEquatable<T>;
+        public static int ToLower(this ReadOnlySpan<char> source, Span<char> destination, CultureInfo culture);
+        public static int ToLowerInvariant(this ReadOnlySpan<char> source, Span<char> destination);
+        public static int ToUpper(this ReadOnlySpan<char> source, Span<char> destination, CultureInfo culture);
+        public static int ToUpperInvariant(this ReadOnlySpan<char> source, Span<char> destination);
+        public static ReadOnlySpan<char> Trim(this ReadOnlySpan<char> span);
+        public static ReadOnlySpan<char> Trim(this ReadOnlySpan<char> span, char trimChar);
+        public static ReadOnlySpan<char> Trim(this ReadOnlySpan<char> span, ReadOnlySpan<char> trimChars);
+        public static ReadOnlySpan<char> TrimEnd(this ReadOnlySpan<char> span);
+        public static ReadOnlySpan<char> TrimEnd(this ReadOnlySpan<char> span, char trimChar);
+        public static ReadOnlySpan<char> TrimEnd(this ReadOnlySpan<char> span, ReadOnlySpan<char> trimChars);
+        public static ReadOnlySpan<char> TrimStart(this ReadOnlySpan<char> span);
+        public static ReadOnlySpan<char> TrimStart(this ReadOnlySpan<char> span, char trimChar);
+        public static ReadOnlySpan<char> TrimStart(this ReadOnlySpan<char> span, ReadOnlySpan<char> trimChars);
+    }
-    public class MissingMethodException : MissingMemberException, ISerializable
+    public class MissingMethodException : MissingMemberException
     public class Random {
+        public virtual void NextBytes(Span<byte> buffer);
     }
+    public readonly struct ReadOnlyMemory<T> {
+        public ReadOnlyMemory(T[] array);
+        public ReadOnlyMemory(T[] array, int start, int length);
+        public static ReadOnlyMemory<T> Empty { get; }
+        public bool IsEmpty { get; }
+        public int Length { get; }
+        public ReadOnlySpan<T> Span { get; }
+        public void CopyTo(Memory<T> destination);
+        public override bool Equals(object obj);
+        public bool Equals(ReadOnlyMemory<T> other);
+        public override int GetHashCode();
+        public static implicit operator ReadOnlyMemory<T> (ArraySegment<T> segment);
+        public static implicit operator ReadOnlyMemory<T> (T[] array);
+        public MemoryHandle Pin();
+        public ReadOnlyMemory<T> Slice(int start);
+        public ReadOnlyMemory<T> Slice(int start, int length);
+        public T[] ToArray();
+        public override string ToString();
+        public bool TryCopyTo(Memory<T> destination);
+    }
+    public readonly ref struct ReadOnlySpan<T> {
+        public unsafe ReadOnlySpan(void* pointer, int length);
+        public ReadOnlySpan(T[] array);
+        public ReadOnlySpan(T[] array, int start, int length);
+        public static ReadOnlySpan<T> Empty { get; }
+        public bool IsEmpty { get; }
+        public int Length { get; }
+        public ref readonly T this[int index] { get; }
+        public void CopyTo(Span<T> destination);
+        public override bool Equals(object obj);
+        public ReadOnlySpan<T>.Enumerator GetEnumerator();
+        public override int GetHashCode();
+        public ref readonly T GetPinnableReference();
+        public static bool operator ==(ReadOnlySpan<T> left, ReadOnlySpan<T> right);
+        public static implicit operator ReadOnlySpan<T> (ArraySegment<T> segment);
+        public static implicit operator ReadOnlySpan<T> (T[] array);
+        public static bool operator !=(ReadOnlySpan<T> left, ReadOnlySpan<T> right);
+        public ReadOnlySpan<T> Slice(int start);
+        public ReadOnlySpan<T> Slice(int start, int length);
+        public T[] ToArray();
+        public override string ToString();
+        public bool TryCopyTo(Span<T> destination);
+        public ref struct Enumerator {
+            public ref readonly T Current { get; }
+            public bool MoveNext();
+        }
+    }
-    public struct RuntimeArgumentHandle
+    public ref struct RuntimeArgumentHandle
     public struct SByte : IComparable, IComparable<sbyte>, IConvertible, IEquatable<sbyte>, IFormattable {
+        public static SByte Parse(ReadOnlySpan<char> s, NumberStyles style = (NumberStyles)(7), IFormatProvider provider = null);
+        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider provider = null);
+        public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out SByte result);
+        public static bool TryParse(ReadOnlySpan<char> s, out SByte result);
     }
+    public readonly struct SequencePosition : IEquatable<SequencePosition> {
+        public SequencePosition(object @object, int integer);
+        public override bool Equals(object obj);
+        public bool Equals(SequencePosition other);
+        public override int GetHashCode();
+        public int GetInteger();
+        public object GetObject();
+    }
     public struct Single : IComparable, IComparable<float>, IConvertible, IEquatable<float>, IFormattable {
+        public static bool IsFinite(Single f);
+        public static bool IsNegative(Single f);
+        public static bool IsNormal(Single f);
+        public static bool IsSubnormal(Single f);
+        public static Single Parse(ReadOnlySpan<char> s, NumberStyles style = (NumberStyles)(231), IFormatProvider provider = null);
+        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider provider = null);
+        public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out Single result);
+        public static bool TryParse(ReadOnlySpan<char> s, out Single result);
     }
+    public readonly ref struct Span<T> {
+        public unsafe Span(void* pointer, int length);
+        public Span(T[] array);
+        public Span(T[] array, int start, int length);
+        public static Span<T> Empty { get; }
+        public bool IsEmpty { get; }
+        public int Length { get; }
+        public ref T this[int index] { get; }
+        public void Clear();
+        public void CopyTo(Span<T> destination);
+        public override bool Equals(object obj);
+        public void Fill(T value);
+        public Span<T>.Enumerator GetEnumerator();
+        public override int GetHashCode();
+        public ref T GetPinnableReference();
+        public static bool operator ==(Span<T> left, Span<T> right);
+        public static implicit operator Span<T> (ArraySegment<T> segment);
+        public static implicit operator ReadOnlySpan<T> (Span<T> span);
+        public static implicit operator Span<T> (T[] array);
+        public static bool operator !=(Span<T> left, Span<T> right);
+        public Span<T> Slice(int start);
+        public Span<T> Slice(int start, int length);
+        public T[] ToArray();
+        public override string ToString();
+        public bool TryCopyTo(Span<T> destination);
+        public ref struct Enumerator {
+            public ref T Current { get; }
+            public bool MoveNext();
+        }
+    }
     public sealed class String : ICloneable, IComparable, IComparable<string>, IConvertible, IEnumerable, IEnumerable<char>, IEquatable<string> {
+        public String(ReadOnlySpan<char> value);
+        public bool Contains(char value);
+        public bool Contains(char value, StringComparison comparisonType);
+        public bool Contains(String value, StringComparison comparisonType);
+        public static String Create<TState>(int length, TState state, SpanAction<char, TState> action);
+        public int IndexOf(char value, StringComparison comparisonType);
+        public static implicit operator ReadOnlySpan<char> (String value);
     }
     public abstract class StringComparer : IComparer, IComparer<string>, IEqualityComparer, IEqualityComparer<string> {
+        public static StringComparer Create(CultureInfo culture, CompareOptions options);
     }
     public struct TimeSpan : IComparable, IComparable<TimeSpan>, IEquatable<TimeSpan>, IFormattable {
+        public static TimeSpan Parse(ReadOnlySpan<char> input, IFormatProvider formatProvider = null);
+        public static TimeSpan ParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider formatProvider, TimeSpanStyles styles = (TimeSpanStyles)(0));
+        public static TimeSpan ParseExact(ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, TimeSpanStyles styles = (TimeSpanStyles)(0));
+        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider formatProvider = null);
+        public static bool TryParse(ReadOnlySpan<char> input, IFormatProvider formatProvider, out TimeSpan result);
+        public static bool TryParse(ReadOnlySpan<char> s, out TimeSpan result);
+        public static bool TryParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider formatProvider, TimeSpanStyles styles, out TimeSpan result);
+        public static bool TryParseExact(ReadOnlySpan<char> input, ReadOnlySpan<char> format, IFormatProvider formatProvider, out TimeSpan result);
+        public static bool TryParseExact(ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, TimeSpanStyles styles, out TimeSpan result);
+        public static bool TryParseExact(ReadOnlySpan<char> input, string[] formats, IFormatProvider formatProvider, out TimeSpan result);
     }
     public sealed class TimeZoneInfo : IDeserializationCallback, IEquatable<TimeZoneInfo>, ISerializable {
-        public struct TransitionTime : IDeserializationCallback, IEquatable<TimeZoneInfo.TransitionTime>, ISerializable
+        public readonly struct TransitionTime : IDeserializationCallback, IEquatable<TimeZoneInfo.TransitionTime>, ISerializable
     }
     public abstract class Type : MemberInfo, IReflect {
+        public virtual bool IsByRefLike { get; }
+        public virtual bool IsGenericMethodParameter { get; }
+        public virtual bool IsGenericTypeParameter { get; }
+        public virtual bool IsSignatureType { get; }
+        public MethodInfo GetMethod(string name, int genericParameterCount, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers);
+        public MethodInfo GetMethod(string name, int genericParameterCount, BindingFlags bindingAttr, Binder binder, Type[] types, ParameterModifier[] modifiers);
+        public MethodInfo GetMethod(string name, int genericParameterCount, Type[] types);
+        public MethodInfo GetMethod(string name, int genericParameterCount, Type[] types, ParameterModifier[] modifiers);
+        protected virtual MethodInfo GetMethodImpl(string name, int genericParameterCount, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers);
+        public static Type MakeGenericMethodParameter(int position);
     }
-    public struct TypedReference
+    public ref struct TypedReference
-    public class TypeUnloadedException : SystemException, ISerializable
+    public class TypeUnloadedException : SystemException
     public struct UInt16 : IComparable, IComparable<ushort>, IConvertible, IEquatable<ushort>, IFormattable {
+        public static UInt16 Parse(ReadOnlySpan<char> s, NumberStyles style = (NumberStyles)(7), IFormatProvider provider = null);
+        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider provider = null);
+        public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out UInt16 result);
+        public static bool TryParse(ReadOnlySpan<char> s, out UInt16 result);
     }
     public struct UInt32 : IComparable, IComparable<uint>, IConvertible, IEquatable<uint>, IFormattable {
+        public static UInt32 Parse(ReadOnlySpan<char> s, NumberStyles style = (NumberStyles)(7), IFormatProvider provider = null);
+        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider provider = null);
+        public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out UInt32 result);
+        public static bool TryParse(ReadOnlySpan<char> s, out UInt32 result);
     }
     public struct UInt64 : IComparable, IComparable<ulong>, IConvertible, IEquatable<ulong>, IFormattable {
+        public static UInt64 Parse(ReadOnlySpan<char> s, NumberStyles style = (NumberStyles)(7), IFormatProvider provider = null);
+        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>), IFormatProvider provider = null);
+        public static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider provider, out UInt64 result);
+        public static bool TryParse(ReadOnlySpan<char> s, out UInt64 result);
     }
     public sealed class Version : ICloneable, IComparable, IComparable<Version>, IEquatable<Version> {
+        public static Version Parse(ReadOnlySpan<char> input);
+        public bool TryFormat(Span<char> destination, out int charsWritten);
+        public bool TryFormat(Span<char> destination, int fieldCount, out int charsWritten);
+        public static bool TryParse(ReadOnlySpan<char> input, out Version result);
     }
 }
```