# System.Collections.Immutable

``` diff
+namespace System.Collections.Immutable {
+    public interface IImmutableDictionary<TKey, TValue> : IEnumerable, IEnumerable<KeyValuePair<TKey, TValue>>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IReadOnlyDictionary<TKey, TValue> {
+        IImmutableDictionary<TKey, TValue> Add(TKey key, TValue value);
+        IImmutableDictionary<TKey, TValue> AddRange(IEnumerable<KeyValuePair<TKey, TValue>> pairs);
+        IImmutableDictionary<TKey, TValue> Clear();
+        bool Contains(KeyValuePair<TKey, TValue> pair);
+        IImmutableDictionary<TKey, TValue> Remove(TKey key);
+        IImmutableDictionary<TKey, TValue> RemoveRange(IEnumerable<TKey> keys);
+        IImmutableDictionary<TKey, TValue> SetItem(TKey key, TValue value);
+        IImmutableDictionary<TKey, TValue> SetItems(IEnumerable<KeyValuePair<TKey, TValue>> items);
+        bool TryGetKey(TKey equalKey, out TKey actualKey);
+    }
+    public interface IImmutableList<T> : IEnumerable, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T> {
+        IImmutableList<T> Add(T value);
+        IImmutableList<T> AddRange(IEnumerable<T> items);
+        IImmutableList<T> Clear();
+        int IndexOf(T item, int index, int count, IEqualityComparer<T> equalityComparer);
+        IImmutableList<T> Insert(int index, T element);
+        IImmutableList<T> InsertRange(int index, IEnumerable<T> items);
+        int LastIndexOf(T item, int index, int count, IEqualityComparer<T> equalityComparer);
+        IImmutableList<T> Remove(T value, IEqualityComparer<T> equalityComparer);
+        IImmutableList<T> RemoveAll(Predicate<T> match);
+        IImmutableList<T> RemoveAt(int index);
+        IImmutableList<T> RemoveRange(IEnumerable<T> items, IEqualityComparer<T> equalityComparer);
+        IImmutableList<T> RemoveRange(int index, int count);
+        IImmutableList<T> Replace(T oldValue, T newValue, IEqualityComparer<T> equalityComparer);
+        IImmutableList<T> SetItem(int index, T value);
+    }
+    public interface IImmutableQueue<T> : IEnumerable, IEnumerable<T> {
+        bool IsEmpty { get; }
+        IImmutableQueue<T> Clear();
+        IImmutableQueue<T> Dequeue();
+        IImmutableQueue<T> Enqueue(T value);
+        T Peek();
+    }
+    public interface IImmutableSet<T> : IEnumerable, IEnumerable<T>, IReadOnlyCollection<T> {
+        IImmutableSet<T> Add(T value);
+        IImmutableSet<T> Clear();
+        bool Contains(T value);
+        IImmutableSet<T> Except(IEnumerable<T> other);
+        IImmutableSet<T> Intersect(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);
+        IImmutableSet<T> Remove(T value);
+        bool SetEquals(IEnumerable<T> other);
+        IImmutableSet<T> SymmetricExcept(IEnumerable<T> other);
+        bool TryGetValue(T equalValue, out T actualValue);
+        IImmutableSet<T> Union(IEnumerable<T> other);
+    }
+    public interface IImmutableStack<T> : IEnumerable, IEnumerable<T> {
+        bool IsEmpty { get; }
+        IImmutableStack<T> Clear();
+        T Peek();
+        IImmutableStack<T> Pop();
+        IImmutableStack<T> Push(T value);
+    }
+    public static class ImmutableArray {
+        public static int BinarySearch<T>(this ImmutableArray<T> array, int index, int length, T value);
+        public static int BinarySearch<T>(this ImmutableArray<T> array, int index, int length, T value, IComparer<T> comparer);
+        public static int BinarySearch<T>(this ImmutableArray<T> array, T value);
+        public static int BinarySearch<T>(this ImmutableArray<T> array, T value, IComparer<T> comparer);
+        public static ImmutableArray<T> Create<T>();
+        public static ImmutableArray<T> Create<T>(ImmutableArray<T> items, int start, int length);
+        public static ImmutableArray<T> Create<T>(T item);
+        public static ImmutableArray<T> Create<T>(T item1, T item2);
+        public static ImmutableArray<T> Create<T>(T item1, T item2, T item3);
+        public static ImmutableArray<T> Create<T>(T item1, T item2, T item3, T item4);
+        public static ImmutableArray<T> Create<T>(params T[] items);
+        public static ImmutableArray<T> Create<T>(T[] items, int start, int length);
+        public static ImmutableArray<T>.Builder CreateBuilder<T>();
+        public static ImmutableArray<T>.Builder CreateBuilder<T>(int initialCapacity);
+        public static ImmutableArray<T> CreateRange<T>(IEnumerable<T> items);
+        public static ImmutableArray<TResult> CreateRange<TSource, TArg, TResult>(ImmutableArray<TSource> items, Func<TSource, TArg, TResult> selector, TArg arg);
+        public static ImmutableArray<TResult> CreateRange<TSource, TArg, TResult>(ImmutableArray<TSource> items, int start, int length, Func<TSource, TArg, TResult> selector, TArg arg);
+        public static ImmutableArray<TResult> CreateRange<TSource, TResult>(ImmutableArray<TSource> items, Func<TSource, TResult> selector);
+        public static ImmutableArray<TResult> CreateRange<TSource, TResult>(ImmutableArray<TSource> items, int start, int length, Func<TSource, TResult> selector);
+        public static ImmutableArray<TSource> ToImmutableArray<TSource>(this ImmutableArray<TSource>.Builder builder);
+        public static ImmutableArray<TSource> ToImmutableArray<TSource>(this IEnumerable<TSource> items);
+    }
+    public struct ImmutableArray<T> : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IEquatable<ImmutableArray<T>>, IImmutableList<T>, IList, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, IStructuralComparable, IStructuralEquatable {
+        public static readonly ImmutableArray<T> Empty;
+        public bool IsDefault { get; }
+        public bool IsDefaultOrEmpty { get; }
+        public bool IsEmpty { get; }
+        public int Length { get; }
+        int System.Collections.Generic.ICollection<T>.Count { get; }
+        bool System.Collections.Generic.ICollection<T>.IsReadOnly { get; }
+        T System.Collections.Generic.IList<T>.this[int index] { get; set; }
+        int System.Collections.Generic.IReadOnlyCollection<T>.Count { get; }
+        T System.Collections.Generic.IReadOnlyList<T>.this[int index] { get; }
+        int System.Collections.ICollection.Count { get; }
+        bool System.Collections.ICollection.IsSynchronized { get; }
+        object System.Collections.ICollection.SyncRoot { get; }
+        bool System.Collections.IList.IsFixedSize { get; }
+        bool System.Collections.IList.IsReadOnly { get; }
+        object System.Collections.IList.this[int index] { get; set; }
+        public T this[int index] { get; }
+        public ImmutableArray<T> Add(T item);
+        public ImmutableArray<T> AddRange(IEnumerable<T> items);
+        public ImmutableArray<T> AddRange(ImmutableArray<T> items);
+        public ImmutableArray<TOther> As<TOther>() where TOther : class;
+        public ReadOnlyMemory<T> AsMemory();
+        public ReadOnlySpan<T> AsSpan();
+        public ImmutableArray<TOther> CastArray<TOther>() where TOther : class;
+        public static ImmutableArray<T> CastUp<TDerived>(ImmutableArray<TDerived> items) where TDerived : class, T;
+        public ImmutableArray<T> Clear();
+        public bool Contains(T item);
+        public void CopyTo(int sourceIndex, T[] destination, int destinationIndex, int length);
+        public void CopyTo(T[] destination);
+        public void CopyTo(T[] destination, int destinationIndex);
+        public bool Equals(ImmutableArray<T> other);
+        public override bool Equals(object obj);
+        public ImmutableArray<T>.Enumerator GetEnumerator();
+        public override int GetHashCode();
+        public int IndexOf(T item);
+        public int IndexOf(T item, int startIndex);
+        public int IndexOf(T item, int startIndex, IEqualityComparer<T> equalityComparer);
+        public int IndexOf(T item, int startIndex, int count);
+        public int IndexOf(T item, int startIndex, int count, IEqualityComparer<T> equalityComparer);
+        public ImmutableArray<T> Insert(int index, T item);
+        public ImmutableArray<T> InsertRange(int index, IEnumerable<T> items);
+        public ImmutableArray<T> InsertRange(int index, ImmutableArray<T> items);
+        public ref readonly T ItemRef(int index);
+        public int LastIndexOf(T item);
+        public int LastIndexOf(T item, int startIndex);
+        public int LastIndexOf(T item, int startIndex, int count);
+        public int LastIndexOf(T item, int startIndex, int count, IEqualityComparer<T> equalityComparer);
+        public IEnumerable<TResult> OfType<TResult>();
+        public static bool operator ==(ImmutableArray<T> left, ImmutableArray<T> right);
+        public static bool operator ==(ImmutableArray<T>? left, ImmutableArray<T>? right);
+        public static bool operator !=(ImmutableArray<T> left, ImmutableArray<T> right);
+        public static bool operator !=(ImmutableArray<T>? left, ImmutableArray<T>? right);
+        public ImmutableArray<T> Remove(T item);
+        public ImmutableArray<T> Remove(T item, IEqualityComparer<T> equalityComparer);
+        public ImmutableArray<T> RemoveAll(Predicate<T> match);
+        public ImmutableArray<T> RemoveAt(int index);
+        public ImmutableArray<T> RemoveRange(IEnumerable<T> items);
+        public ImmutableArray<T> RemoveRange(IEnumerable<T> items, IEqualityComparer<T> equalityComparer);
+        public ImmutableArray<T> RemoveRange(ImmutableArray<T> items);
+        public ImmutableArray<T> RemoveRange(ImmutableArray<T> items, IEqualityComparer<T> equalityComparer);
+        public ImmutableArray<T> RemoveRange(int index, int length);
+        public ImmutableArray<T> Replace(T oldValue, T newValue);
+        public ImmutableArray<T> Replace(T oldValue, T newValue, IEqualityComparer<T> equalityComparer);
+        public ImmutableArray<T> SetItem(int index, T item);
+        public ImmutableArray<T> Sort();
+        public ImmutableArray<T> Sort(IComparer<T> comparer);
+        public ImmutableArray<T> Sort(Comparison<T> comparison);
+        public ImmutableArray<T> Sort(int index, int count, IComparer<T> comparer);
+        void System.Collections.Generic.ICollection<T>.Add(T item);
+        void System.Collections.Generic.ICollection<T>.Clear();
+        bool System.Collections.Generic.ICollection<T>.Remove(T item);
+        IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator();
+        void System.Collections.Generic.IList<T>.Insert(int index, T item);
+        void System.Collections.Generic.IList<T>.RemoveAt(int index);
+        void System.Collections.ICollection.CopyTo(Array array, int index);
+        IEnumerator System.Collections.IEnumerable.GetEnumerator();
+        int System.Collections.IList.Add(object value);
+        void System.Collections.IList.Clear();
+        bool System.Collections.IList.Contains(object value);
+        int System.Collections.IList.IndexOf(object value);
+        void System.Collections.IList.Insert(int index, object value);
+        void System.Collections.IList.Remove(object value);
+        void System.Collections.IList.RemoveAt(int index);
+        IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.Add(T value);
+        IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.AddRange(IEnumerable<T> items);
+        IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.Clear();
+        IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.Insert(int index, T element);
+        IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.InsertRange(int index, IEnumerable<T> items);
+        IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.Remove(T value, IEqualityComparer<T> equalityComparer);
+        IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.RemoveAll(Predicate<T> match);
+        IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.RemoveAt(int index);
+        IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.RemoveRange(IEnumerable<T> items, IEqualityComparer<T> equalityComparer);
+        IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.RemoveRange(int index, int count);
+        IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.Replace(T oldValue, T newValue, IEqualityComparer<T> equalityComparer);
+        IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.SetItem(int index, T value);
+        int System.Collections.IStructuralComparable.CompareTo(object other, IComparer comparer);
+        bool System.Collections.IStructuralEquatable.Equals(object other, IEqualityComparer comparer);
+        int System.Collections.IStructuralEquatable.GetHashCode(IEqualityComparer comparer);
+        public ImmutableArray<T>.Builder ToBuilder();
+        public sealed class Builder : ICollection<T>, IEnumerable, IEnumerable<T>, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T> {
+            public int Capacity { get; set; }
+            public int Count { get; set; }
+            bool System.Collections.Generic.ICollection<T>.IsReadOnly { get; }
+            public T this[int index] { get; set; }
+            public void Add(T item);
+            public void AddRange(ImmutableArray<T>.Builder items);
+            public void AddRange(IEnumerable<T> items);
+            public void AddRange(ImmutableArray<T> items);
+            public void AddRange(ImmutableArray<T> items, int length);
+            public void AddRange(params T[] items);
+            public void AddRange(T[] items, int length);
+            public void AddRange<TDerived>(ImmutableArray<TDerived>.Builder items) where TDerived : T;
+            public void AddRange<TDerived>(ImmutableArray<TDerived> items) where TDerived : T;
+            public void AddRange<TDerived>(TDerived[] items) where TDerived : T;
+            public void Clear();
+            public bool Contains(T item);
+            public void CopyTo(T[] array, int index);
+            public IEnumerator<T> GetEnumerator();
+            public int IndexOf(T item);
+            public int IndexOf(T item, int startIndex);
+            public int IndexOf(T item, int startIndex, int count);
+            public int IndexOf(T item, int startIndex, int count, IEqualityComparer<T> equalityComparer);
+            public void Insert(int index, T item);
+            public ref readonly T ItemRef(int index);
+            public int LastIndexOf(T item);
+            public int LastIndexOf(T item, int startIndex);
+            public int LastIndexOf(T item, int startIndex, int count);
+            public int LastIndexOf(T item, int startIndex, int count, IEqualityComparer<T> equalityComparer);
+            public ImmutableArray<T> MoveToImmutable();
+            public bool Remove(T element);
+            public void RemoveAt(int index);
+            public void Reverse();
+            public void Sort();
+            public void Sort(IComparer<T> comparer);
+            public void Sort(Comparison<T> comparison);
+            public void Sort(int index, int count, IComparer<T> comparer);
+            IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator();
+            IEnumerator System.Collections.IEnumerable.GetEnumerator();
+            public T[] ToArray();
+            public ImmutableArray<T> ToImmutable();
+        }
+        public struct Enumerator {
+            public T Current { get; }
+            public bool MoveNext();
+        }
+    }
+    public static class ImmutableDictionary {
+        public static bool Contains<TKey, TValue>(this IImmutableDictionary<TKey, TValue> map, TKey key, TValue value);
+        public static ImmutableDictionary<TKey, TValue> Create<TKey, TValue>();
+        public static ImmutableDictionary<TKey, TValue> Create<TKey, TValue>(IEqualityComparer<TKey> keyComparer);
+        public static ImmutableDictionary<TKey, TValue> Create<TKey, TValue>(IEqualityComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer);
+        public static ImmutableDictionary<TKey, TValue>.Builder CreateBuilder<TKey, TValue>();
+        public static ImmutableDictionary<TKey, TValue>.Builder CreateBuilder<TKey, TValue>(IEqualityComparer<TKey> keyComparer);
+        public static ImmutableDictionary<TKey, TValue>.Builder CreateBuilder<TKey, TValue>(IEqualityComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer);
+        public static ImmutableDictionary<TKey, TValue> CreateRange<TKey, TValue>(IEnumerable<KeyValuePair<TKey, TValue>> items);
+        public static ImmutableDictionary<TKey, TValue> CreateRange<TKey, TValue>(IEqualityComparer<TKey> keyComparer, IEnumerable<KeyValuePair<TKey, TValue>> items);
+        public static ImmutableDictionary<TKey, TValue> CreateRange<TKey, TValue>(IEqualityComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer, IEnumerable<KeyValuePair<TKey, TValue>> items);
+        public static TValue GetValueOrDefault<TKey, TValue>(this IImmutableDictionary<TKey, TValue> dictionary, TKey key);
+        public static TValue GetValueOrDefault<TKey, TValue>(this IImmutableDictionary<TKey, TValue> dictionary, TKey key, TValue defaultValue);
+        public static ImmutableDictionary<TKey, TValue> ToImmutableDictionary<TKey, TValue>(this ImmutableDictionary<TKey, TValue>.Builder builder);
+        public static ImmutableDictionary<TKey, TValue> ToImmutableDictionary<TKey, TValue>(this IEnumerable<KeyValuePair<TKey, TValue>> source);
+        public static ImmutableDictionary<TKey, TValue> ToImmutableDictionary<TKey, TValue>(this IEnumerable<KeyValuePair<TKey, TValue>> source, IEqualityComparer<TKey> keyComparer);
+        public static ImmutableDictionary<TKey, TValue> ToImmutableDictionary<TKey, TValue>(this IEnumerable<KeyValuePair<TKey, TValue>> source, IEqualityComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer);
+        public static ImmutableDictionary<TKey, TValue> ToImmutableDictionary<TSource, TKey, TValue>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TValue> elementSelector);
+        public static ImmutableDictionary<TKey, TValue> ToImmutableDictionary<TSource, TKey, TValue>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TValue> elementSelector, IEqualityComparer<TKey> keyComparer);
+        public static ImmutableDictionary<TKey, TValue> ToImmutableDictionary<TSource, TKey, TValue>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TValue> elementSelector, IEqualityComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer);
+        public static ImmutableDictionary<TKey, TSource> ToImmutableDictionary<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector);
+        public static ImmutableDictionary<TKey, TSource> ToImmutableDictionary<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> keyComparer);
+    }
+    public sealed class ImmutableDictionary<TKey, TValue> : ICollection, ICollection<KeyValuePair<TKey, TValue>>, IDictionary, IDictionary<TKey, TValue>, IEnumerable, IEnumerable<KeyValuePair<TKey, TValue>>, IImmutableDictionary<TKey, TValue>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IReadOnlyDictionary<TKey, TValue> {
+        public static readonly ImmutableDictionary<TKey, TValue> Empty;
+        public int Count { get; }
+        public bool IsEmpty { get; }
+        public IEqualityComparer<TKey> KeyComparer { get; }
+        public IEnumerable<TKey> Keys { get; }
+        bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.IsReadOnly { get; }
+        TValue System.Collections.Generic.IDictionary<TKey,TValue>.this[TKey key] { get; set; }
+        ICollection<TKey> System.Collections.Generic.IDictionary<TKey,TValue>.Keys { get; }
+        ICollection<TValue> System.Collections.Generic.IDictionary<TKey,TValue>.Values { get; }
+        bool System.Collections.ICollection.IsSynchronized { get; }
+        object System.Collections.ICollection.SyncRoot { get; }
+        bool System.Collections.IDictionary.IsFixedSize { get; }
+        bool System.Collections.IDictionary.IsReadOnly { get; }
+        object System.Collections.IDictionary.this[object key] { get; set; }
+        ICollection System.Collections.IDictionary.Keys { get; }
+        ICollection System.Collections.IDictionary.Values { get; }
+        public TValue this[TKey key] { get; }
+        public IEqualityComparer<TValue> ValueComparer { get; }
+        public IEnumerable<TValue> Values { get; }
+        public ImmutableDictionary<TKey, TValue> Add(TKey key, TValue value);
+        public ImmutableDictionary<TKey, TValue> AddRange(IEnumerable<KeyValuePair<TKey, TValue>> pairs);
+        public ImmutableDictionary<TKey, TValue> Clear();
+        public bool Contains(KeyValuePair<TKey, TValue> pair);
+        public bool ContainsKey(TKey key);
+        public bool ContainsValue(TValue value);
+        public ImmutableDictionary<TKey, TValue>.Enumerator GetEnumerator();
+        public ImmutableDictionary<TKey, TValue> Remove(TKey key);
+        public ImmutableDictionary<TKey, TValue> RemoveRange(IEnumerable<TKey> keys);
+        public ImmutableDictionary<TKey, TValue> SetItem(TKey key, TValue value);
+        public ImmutableDictionary<TKey, TValue> SetItems(IEnumerable<KeyValuePair<TKey, TValue>> items);
+        void System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.Add(KeyValuePair<TKey, TValue> item);
+        void System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.Clear();
+        void System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex);
+        bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.Remove(KeyValuePair<TKey, TValue> item);
+        void System.Collections.Generic.IDictionary<TKey,TValue>.Add(TKey key, TValue value);
+        bool System.Collections.Generic.IDictionary<TKey,TValue>.Remove(TKey key);
+        IEnumerator<KeyValuePair<TKey, TValue>> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey,TValue>>.GetEnumerator();
+        void System.Collections.ICollection.CopyTo(Array array, int arrayIndex);
+        void System.Collections.IDictionary.Add(object key, object value);
+        void System.Collections.IDictionary.Clear();
+        bool System.Collections.IDictionary.Contains(object key);
+        IDictionaryEnumerator System.Collections.IDictionary.GetEnumerator();
+        void System.Collections.IDictionary.Remove(object key);
+        IEnumerator System.Collections.IEnumerable.GetEnumerator();
+        IImmutableDictionary<TKey, TValue> System.Collections.Immutable.IImmutableDictionary<TKey,TValue>.Add(TKey key, TValue value);
+        IImmutableDictionary<TKey, TValue> System.Collections.Immutable.IImmutableDictionary<TKey,TValue>.AddRange(IEnumerable<KeyValuePair<TKey, TValue>> pairs);
+        IImmutableDictionary<TKey, TValue> System.Collections.Immutable.IImmutableDictionary<TKey,TValue>.Clear();
+        IImmutableDictionary<TKey, TValue> System.Collections.Immutable.IImmutableDictionary<TKey,TValue>.Remove(TKey key);
+        IImmutableDictionary<TKey, TValue> System.Collections.Immutable.IImmutableDictionary<TKey,TValue>.RemoveRange(IEnumerable<TKey> keys);
+        IImmutableDictionary<TKey, TValue> System.Collections.Immutable.IImmutableDictionary<TKey,TValue>.SetItem(TKey key, TValue value);
+        IImmutableDictionary<TKey, TValue> System.Collections.Immutable.IImmutableDictionary<TKey,TValue>.SetItems(IEnumerable<KeyValuePair<TKey, TValue>> items);
+        public ImmutableDictionary<TKey, TValue>.Builder ToBuilder();
+        public bool TryGetKey(TKey equalKey, out TKey actualKey);
+        public bool TryGetValue(TKey key, out TValue value);
+        public ImmutableDictionary<TKey, TValue> WithComparers(IEqualityComparer<TKey> keyComparer);
+        public ImmutableDictionary<TKey, TValue> WithComparers(IEqualityComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer);
+        public sealed class Builder : ICollection, ICollection<KeyValuePair<TKey, TValue>>, IDictionary, IDictionary<TKey, TValue>, IEnumerable, IEnumerable<KeyValuePair<TKey, TValue>>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IReadOnlyDictionary<TKey, TValue> {
+            public int Count { get; }
+            public IEqualityComparer<TKey> KeyComparer { get; set; }
+            public IEnumerable<TKey> Keys { get; }
+            bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.IsReadOnly { get; }
+            ICollection<TKey> System.Collections.Generic.IDictionary<TKey,TValue>.Keys { get; }
+            ICollection<TValue> System.Collections.Generic.IDictionary<TKey,TValue>.Values { get; }
+            bool System.Collections.ICollection.IsSynchronized { get; }
+            object System.Collections.ICollection.SyncRoot { get; }
+            bool System.Collections.IDictionary.IsFixedSize { get; }
+            bool System.Collections.IDictionary.IsReadOnly { get; }
+            object System.Collections.IDictionary.this[object key] { get; set; }
+            ICollection System.Collections.IDictionary.Keys { get; }
+            ICollection System.Collections.IDictionary.Values { get; }
+            public TValue this[TKey key] { get; set; }
+            public IEqualityComparer<TValue> ValueComparer { get; set; }
+            public IEnumerable<TValue> Values { get; }
+            public void Add(KeyValuePair<TKey, TValue> item);
+            public void Add(TKey key, TValue value);
+            public void AddRange(IEnumerable<KeyValuePair<TKey, TValue>> items);
+            public void Clear();
+            public bool Contains(KeyValuePair<TKey, TValue> item);
+            public bool ContainsKey(TKey key);
+            public bool ContainsValue(TValue value);
+            public ImmutableDictionary<TKey, TValue>.Enumerator GetEnumerator();
+            public TValue GetValueOrDefault(TKey key);
+            public TValue GetValueOrDefault(TKey key, TValue defaultValue);
+            public bool Remove(KeyValuePair<TKey, TValue> item);
+            public bool Remove(TKey key);
+            public void RemoveRange(IEnumerable<TKey> keys);
+            void System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex);
+            IEnumerator<KeyValuePair<TKey, TValue>> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey,TValue>>.GetEnumerator();
+            void System.Collections.ICollection.CopyTo(Array array, int arrayIndex);
+            void System.Collections.IDictionary.Add(object key, object value);
+            bool System.Collections.IDictionary.Contains(object key);
+            IDictionaryEnumerator System.Collections.IDictionary.GetEnumerator();
+            void System.Collections.IDictionary.Remove(object key);
+            IEnumerator System.Collections.IEnumerable.GetEnumerator();
+            public ImmutableDictionary<TKey, TValue> ToImmutable();
+            public bool TryGetKey(TKey equalKey, out TKey actualKey);
+            public bool TryGetValue(TKey key, out TValue value);
+        }
+        public struct Enumerator : IDisposable, IEnumerator, IEnumerator<KeyValuePair<TKey, TValue>> {
+            public KeyValuePair<TKey, TValue> Current { get; }
+            object System.Collections.IEnumerator.Current { get; }
+            public void Dispose();
+            public bool MoveNext();
+            public void Reset();
+        }
+    }
+    public static class ImmutableHashSet {
+        public static ImmutableHashSet<T> Create<T>();
+        public static ImmutableHashSet<T> Create<T>(IEqualityComparer<T> equalityComparer);
+        public static ImmutableHashSet<T> Create<T>(IEqualityComparer<T> equalityComparer, T item);
+        public static ImmutableHashSet<T> Create<T>(IEqualityComparer<T> equalityComparer, params T[] items);
+        public static ImmutableHashSet<T> Create<T>(T item);
+        public static ImmutableHashSet<T> Create<T>(params T[] items);
+        public static ImmutableHashSet<T>.Builder CreateBuilder<T>();
+        public static ImmutableHashSet<T>.Builder CreateBuilder<T>(IEqualityComparer<T> equalityComparer);
+        public static ImmutableHashSet<T> CreateRange<T>(IEnumerable<T> items);
+        public static ImmutableHashSet<T> CreateRange<T>(IEqualityComparer<T> equalityComparer, IEnumerable<T> items);
+        public static ImmutableHashSet<TSource> ToImmutableHashSet<TSource>(this ImmutableHashSet<TSource>.Builder builder);
+        public static ImmutableHashSet<TSource> ToImmutableHashSet<TSource>(this IEnumerable<TSource> source);
+        public static ImmutableHashSet<TSource> ToImmutableHashSet<TSource>(this IEnumerable<TSource> source, IEqualityComparer<TSource> equalityComparer);
+    }
+    public sealed class ImmutableHashSet<T> : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IImmutableSet<T>, IReadOnlyCollection<T>, IReadOnlySet<T>, ISet<T> {
+        public static readonly ImmutableHashSet<T> Empty;
+        public int Count { get; }
+        public bool IsEmpty { get; }
+        public IEqualityComparer<T> KeyComparer { get; }
+        bool System.Collections.Generic.ICollection<T>.IsReadOnly { get; }
+        bool System.Collections.ICollection.IsSynchronized { get; }
+        object System.Collections.ICollection.SyncRoot { get; }
+        public ImmutableHashSet<T> Add(T item);
+        public ImmutableHashSet<T> Clear();
+        public bool Contains(T item);
+        public ImmutableHashSet<T> Except(IEnumerable<T> other);
+        public ImmutableHashSet<T>.Enumerator GetEnumerator();
+        public ImmutableHashSet<T> Intersect(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 ImmutableHashSet<T> Remove(T item);
+        public bool SetEquals(IEnumerable<T> other);
+        public ImmutableHashSet<T> SymmetricExcept(IEnumerable<T> other);
+        void System.Collections.Generic.ICollection<T>.Add(T item);
+        void System.Collections.Generic.ICollection<T>.Clear();
+        void System.Collections.Generic.ICollection<T>.CopyTo(T[] array, int arrayIndex);
+        bool System.Collections.Generic.ICollection<T>.Remove(T item);
+        IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator();
+        bool System.Collections.Generic.ISet<T>.Add(T item);
+        void System.Collections.Generic.ISet<T>.ExceptWith(IEnumerable<T> other);
+        void System.Collections.Generic.ISet<T>.IntersectWith(IEnumerable<T> other);
+        void System.Collections.Generic.ISet<T>.SymmetricExceptWith(IEnumerable<T> other);
+        void System.Collections.Generic.ISet<T>.UnionWith(IEnumerable<T> other);
+        void System.Collections.ICollection.CopyTo(Array array, int arrayIndex);
+        IEnumerator System.Collections.IEnumerable.GetEnumerator();
+        IImmutableSet<T> System.Collections.Immutable.IImmutableSet<T>.Add(T item);
+        IImmutableSet<T> System.Collections.Immutable.IImmutableSet<T>.Clear();
+        IImmutableSet<T> System.Collections.Immutable.IImmutableSet<T>.Except(IEnumerable<T> other);
+        IImmutableSet<T> System.Collections.Immutable.IImmutableSet<T>.Intersect(IEnumerable<T> other);
+        IImmutableSet<T> System.Collections.Immutable.IImmutableSet<T>.Remove(T item);
+        IImmutableSet<T> System.Collections.Immutable.IImmutableSet<T>.SymmetricExcept(IEnumerable<T> other);
+        IImmutableSet<T> System.Collections.Immutable.IImmutableSet<T>.Union(IEnumerable<T> other);
+        public ImmutableHashSet<T>.Builder ToBuilder();
+        public bool TryGetValue(T equalValue, out T actualValue);
+        public ImmutableHashSet<T> Union(IEnumerable<T> other);
+        public ImmutableHashSet<T> WithComparer(IEqualityComparer<T> equalityComparer);
+        public sealed class Builder : ICollection<T>, IEnumerable, IEnumerable<T>, IReadOnlyCollection<T>, ISet<T> {
+            public int Count { get; }
+            public IEqualityComparer<T> KeyComparer { get; set; }
+            bool System.Collections.Generic.ICollection<T>.IsReadOnly { get; }
+            public bool Add(T item);
+            public void Clear();
+            public bool Contains(T item);
+            public void ExceptWith(IEnumerable<T> other);
+            public ImmutableHashSet<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 bool SetEquals(IEnumerable<T> other);
+            public void SymmetricExceptWith(IEnumerable<T> other);
+            void System.Collections.Generic.ICollection<T>.Add(T item);
+            void System.Collections.Generic.ICollection<T>.CopyTo(T[] array, int arrayIndex);
+            IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator();
+            IEnumerator System.Collections.IEnumerable.GetEnumerator();
+            public ImmutableHashSet<T> ToImmutable();
+            public bool TryGetValue(T equalValue, out T actualValue);
+            public void UnionWith(IEnumerable<T> other);
+        }
+        public struct Enumerator : IDisposable, IEnumerator, IEnumerator<T> {
+            public T Current { get; }
+            object System.Collections.IEnumerator.Current { get; }
+            public void Dispose();
+            public bool MoveNext();
+            public void Reset();
+        }
+    }
+    public static class ImmutableInterlocked {
+        public static TValue AddOrUpdate<TKey, TValue>(ref ImmutableDictionary<TKey, TValue> location, TKey key, Func<TKey, TValue> addValueFactory, Func<TKey, TValue, TValue> updateValueFactory);
+        public static TValue AddOrUpdate<TKey, TValue>(ref ImmutableDictionary<TKey, TValue> location, TKey key, TValue addValue, Func<TKey, TValue, TValue> updateValueFactory);
+        public static void Enqueue<T>(ref ImmutableQueue<T> location, T value);
+        public static TValue GetOrAdd<TKey, TValue, TArg>(ref ImmutableDictionary<TKey, TValue> location, TKey key, Func<TKey, TArg, TValue> valueFactory, TArg factoryArgument);
+        public static TValue GetOrAdd<TKey, TValue>(ref ImmutableDictionary<TKey, TValue> location, TKey key, Func<TKey, TValue> valueFactory);
+        public static TValue GetOrAdd<TKey, TValue>(ref ImmutableDictionary<TKey, TValue> location, TKey key, TValue value);
+        public static ImmutableArray<T> InterlockedCompareExchange<T>(ref ImmutableArray<T> location, ImmutableArray<T> value, ImmutableArray<T> comparand);
+        public static ImmutableArray<T> InterlockedExchange<T>(ref ImmutableArray<T> location, ImmutableArray<T> value);
+        public static bool InterlockedInitialize<T>(ref ImmutableArray<T> location, ImmutableArray<T> value);
+        public static void Push<T>(ref ImmutableStack<T> location, T value);
+        public static bool TryAdd<TKey, TValue>(ref ImmutableDictionary<TKey, TValue> location, TKey key, TValue value);
+        public static bool TryDequeue<T>(ref ImmutableQueue<T> location, out T value);
+        public static bool TryPop<T>(ref ImmutableStack<T> location, out T value);
+        public static bool TryRemove<TKey, TValue>(ref ImmutableDictionary<TKey, TValue> location, TKey key, out TValue value);
+        public static bool TryUpdate<TKey, TValue>(ref ImmutableDictionary<TKey, TValue> location, TKey key, TValue newValue, TValue comparisonValue);
+        public static bool Update<T, TArg>(ref ImmutableArray<T> location, Func<ImmutableArray<T>, TArg, ImmutableArray<T>> transformer, TArg transformerArgument);
+        public static bool Update<T, TArg>(ref T location, Func<T, TArg, T> transformer, TArg transformerArgument) where T : class;
+        public static bool Update<T>(ref ImmutableArray<T> location, Func<ImmutableArray<T>, ImmutableArray<T>> transformer);
+        public static bool Update<T>(ref T location, Func<T, T> transformer) where T : class;
+    }
+    public static class ImmutableList {
+        public static ImmutableList<T> Create<T>();
+        public static ImmutableList<T> Create<T>(T item);
+        public static ImmutableList<T> Create<T>(params T[] items);
+        public static ImmutableList<T>.Builder CreateBuilder<T>();
+        public static ImmutableList<T> CreateRange<T>(IEnumerable<T> items);
+        public static int IndexOf<T>(this IImmutableList<T> list, T item);
+        public static int IndexOf<T>(this IImmutableList<T> list, T item, IEqualityComparer<T> equalityComparer);
+        public static int IndexOf<T>(this IImmutableList<T> list, T item, int startIndex);
+        public static int IndexOf<T>(this IImmutableList<T> list, T item, int startIndex, int count);
+        public static int LastIndexOf<T>(this IImmutableList<T> list, T item);
+        public static int LastIndexOf<T>(this IImmutableList<T> list, T item, IEqualityComparer<T> equalityComparer);
+        public static int LastIndexOf<T>(this IImmutableList<T> list, T item, int startIndex);
+        public static int LastIndexOf<T>(this IImmutableList<T> list, T item, int startIndex, int count);
+        public static IImmutableList<T> Remove<T>(this IImmutableList<T> list, T value);
+        public static IImmutableList<T> RemoveRange<T>(this IImmutableList<T> list, IEnumerable<T> items);
+        public static IImmutableList<T> Replace<T>(this IImmutableList<T> list, T oldValue, T newValue);
+        public static ImmutableList<TSource> ToImmutableList<TSource>(this ImmutableList<TSource>.Builder builder);
+        public static ImmutableList<TSource> ToImmutableList<TSource>(this IEnumerable<TSource> source);
+    }
+    public sealed class ImmutableList<T> : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IImmutableList<T>, IList, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T> {
+        public static readonly ImmutableList<T> Empty;
+        public int Count { get; }
+        public bool IsEmpty { get; }
+        bool System.Collections.Generic.ICollection<T>.IsReadOnly { get; }
+        T System.Collections.Generic.IList<T>.this[int index] { get; set; }
+        bool System.Collections.ICollection.IsSynchronized { get; }
+        object System.Collections.ICollection.SyncRoot { get; }
+        bool System.Collections.IList.IsFixedSize { get; }
+        bool System.Collections.IList.IsReadOnly { get; }
+        object System.Collections.IList.this[int index] { get; set; }
+        public T this[int index] { get; }
+        public ImmutableList<T> Add(T value);
+        public ImmutableList<T> AddRange(IEnumerable<T> items);
+        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 ImmutableList<T> Clear();
+        public bool Contains(T value);
+        public ImmutableList<TOutput> ConvertAll<TOutput>(Func<T, TOutput> converter);
+        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 ImmutableList<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 void ForEach(Action<T> action);
+        public ImmutableList<T>.Enumerator GetEnumerator();
+        public ImmutableList<T> GetRange(int index, int count);
+        public int IndexOf(T value);
+        public int IndexOf(T item, int index, int count, IEqualityComparer<T> equalityComparer);
+        public ImmutableList<T> Insert(int index, T item);
+        public ImmutableList<T> InsertRange(int index, IEnumerable<T> items);
+        public ref readonly T ItemRef(int index);
+        public int LastIndexOf(T item, int index, int count, IEqualityComparer<T> equalityComparer);
+        public ImmutableList<T> Remove(T value);
+        public ImmutableList<T> Remove(T value, IEqualityComparer<T> equalityComparer);
+        public ImmutableList<T> RemoveAll(Predicate<T> match);
+        public ImmutableList<T> RemoveAt(int index);
+        public ImmutableList<T> RemoveRange(IEnumerable<T> items);
+        public ImmutableList<T> RemoveRange(IEnumerable<T> items, IEqualityComparer<T> equalityComparer);
+        public ImmutableList<T> RemoveRange(int index, int count);
+        public ImmutableList<T> Replace(T oldValue, T newValue);
+        public ImmutableList<T> Replace(T oldValue, T newValue, IEqualityComparer<T> equalityComparer);
+        public ImmutableList<T> Reverse();
+        public ImmutableList<T> Reverse(int index, int count);
+        public ImmutableList<T> SetItem(int index, T value);
+        public ImmutableList<T> Sort();
+        public ImmutableList<T> Sort(IComparer<T> comparer);
+        public ImmutableList<T> Sort(Comparison<T> comparison);
+        public ImmutableList<T> Sort(int index, int count, IComparer<T> comparer);
+        void System.Collections.Generic.ICollection<T>.Add(T item);
+        void System.Collections.Generic.ICollection<T>.Clear();
+        bool System.Collections.Generic.ICollection<T>.Remove(T item);
+        IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator();
+        void System.Collections.Generic.IList<T>.Insert(int index, T item);
+        void System.Collections.Generic.IList<T>.RemoveAt(int index);
+        void System.Collections.ICollection.CopyTo(Array array, int arrayIndex);
+        IEnumerator System.Collections.IEnumerable.GetEnumerator();
+        int System.Collections.IList.Add(object value);
+        void System.Collections.IList.Clear();
+        bool System.Collections.IList.Contains(object value);
+        int System.Collections.IList.IndexOf(object value);
+        void System.Collections.IList.Insert(int index, object value);
+        void System.Collections.IList.Remove(object value);
+        void System.Collections.IList.RemoveAt(int index);
+        IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.Add(T value);
+        IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.AddRange(IEnumerable<T> items);
+        IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.Clear();
+        IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.Insert(int index, T item);
+        IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.InsertRange(int index, IEnumerable<T> items);
+        IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.Remove(T value, IEqualityComparer<T> equalityComparer);
+        IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.RemoveAll(Predicate<T> match);
+        IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.RemoveAt(int index);
+        IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.RemoveRange(IEnumerable<T> items, IEqualityComparer<T> equalityComparer);
+        IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.RemoveRange(int index, int count);
+        IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.Replace(T oldValue, T newValue, IEqualityComparer<T> equalityComparer);
+        IImmutableList<T> System.Collections.Immutable.IImmutableList<T>.SetItem(int index, T value);
+        public ImmutableList<T>.Builder ToBuilder();
+        public bool TrueForAll(Predicate<T> match);
+        public sealed class Builder : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IList, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T> {
+            public int Count { get; }
+            bool System.Collections.Generic.ICollection<T>.IsReadOnly { get; }
+            bool System.Collections.ICollection.IsSynchronized { get; }
+            object System.Collections.ICollection.SyncRoot { get; }
+            bool System.Collections.IList.IsFixedSize { get; }
+            bool System.Collections.IList.IsReadOnly { get; }
+            object System.Collections.IList.this[int index] { get; set; }
+            public T this[int index] { get; set; }
+            public void Add(T item);
+            public void AddRange(IEnumerable<T> items);
+            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 ImmutableList<TOutput> ConvertAll<TOutput>(Func<T, TOutput> converter);
+            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 ImmutableList<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 void ForEach(Action<T> action);
+            public ImmutableList<T>.Enumerator GetEnumerator();
+            public ImmutableList<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 int IndexOf(T item, int index, int count, IEqualityComparer<T> equalityComparer);
+            public void Insert(int index, T item);
+            public void InsertRange(int index, IEnumerable<T> items);
+            public ref readonly T ItemRef(int index);
+            public int LastIndexOf(T item);
+            public int LastIndexOf(T item, int startIndex);
+            public int LastIndexOf(T item, int startIndex, int count);
+            public int LastIndexOf(T item, int startIndex, int count, IEqualityComparer<T> equalityComparer);
+            public bool Remove(T item);
+            public int RemoveAll(Predicate<T> match);
+            public void RemoveAt(int index);
+            public void Reverse();
+            public void Reverse(int index, int count);
+            public void Sort();
+            public void Sort(IComparer<T> comparer);
+            public void Sort(Comparison<T> comparison);
+            public void Sort(int index, int count, IComparer<T> comparer);
+            IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator();
+            void System.Collections.ICollection.CopyTo(Array array, int arrayIndex);
+            IEnumerator System.Collections.IEnumerable.GetEnumerator();
+            int System.Collections.IList.Add(object value);
+            void System.Collections.IList.Clear();
+            bool System.Collections.IList.Contains(object value);
+            int System.Collections.IList.IndexOf(object value);
+            void System.Collections.IList.Insert(int index, object value);
+            void System.Collections.IList.Remove(object value);
+            public ImmutableList<T> ToImmutable();
+            public bool TrueForAll(Predicate<T> match);
+        }
+        public struct Enumerator : IDisposable, IEnumerator, IEnumerator<T> {
+            public T Current { get; }
+            object System.Collections.IEnumerator.Current { get; }
+            public void Dispose();
+            public bool MoveNext();
+            public void Reset();
+        }
+    }
+    public static class ImmutableQueue {
+        public static ImmutableQueue<T> Create<T>();
+        public static ImmutableQueue<T> Create<T>(T item);
+        public static ImmutableQueue<T> Create<T>(params T[] items);
+        public static ImmutableQueue<T> CreateRange<T>(IEnumerable<T> items);
+        public static IImmutableQueue<T> Dequeue<T>(this IImmutableQueue<T> queue, out T value);
+    }
+    public sealed class ImmutableQueue<T> : IEnumerable, IEnumerable<T>, IImmutableQueue<T> {
+        public static ImmutableQueue<T> Empty { get; }
+        public bool IsEmpty { get; }
+        public ImmutableQueue<T> Clear();
+        public ImmutableQueue<T> Dequeue();
+        public ImmutableQueue<T> Dequeue(out T value);
+        public ImmutableQueue<T> Enqueue(T value);
+        public ImmutableQueue<T>.Enumerator GetEnumerator();
+        public T Peek();
+        public ref readonly T PeekRef();
+        IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator();
+        IEnumerator System.Collections.IEnumerable.GetEnumerator();
+        IImmutableQueue<T> System.Collections.Immutable.IImmutableQueue<T>.Clear();
+        IImmutableQueue<T> System.Collections.Immutable.IImmutableQueue<T>.Dequeue();
+        IImmutableQueue<T> System.Collections.Immutable.IImmutableQueue<T>.Enqueue(T value);
+        public struct Enumerator {
+            public T Current { get; }
+            public bool MoveNext();
+        }
+    }
+    public static class ImmutableSortedDictionary {
+        public static ImmutableSortedDictionary<TKey, TValue> Create<TKey, TValue>();
+        public static ImmutableSortedDictionary<TKey, TValue> Create<TKey, TValue>(IComparer<TKey> keyComparer);
+        public static ImmutableSortedDictionary<TKey, TValue> Create<TKey, TValue>(IComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer);
+        public static ImmutableSortedDictionary<TKey, TValue>.Builder CreateBuilder<TKey, TValue>();
+        public static ImmutableSortedDictionary<TKey, TValue>.Builder CreateBuilder<TKey, TValue>(IComparer<TKey> keyComparer);
+        public static ImmutableSortedDictionary<TKey, TValue>.Builder CreateBuilder<TKey, TValue>(IComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer);
+        public static ImmutableSortedDictionary<TKey, TValue> CreateRange<TKey, TValue>(IComparer<TKey> keyComparer, IEnumerable<KeyValuePair<TKey, TValue>> items);
+        public static ImmutableSortedDictionary<TKey, TValue> CreateRange<TKey, TValue>(IComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer, IEnumerable<KeyValuePair<TKey, TValue>> items);
+        public static ImmutableSortedDictionary<TKey, TValue> CreateRange<TKey, TValue>(IEnumerable<KeyValuePair<TKey, TValue>> items);
+        public static ImmutableSortedDictionary<TKey, TValue> ToImmutableSortedDictionary<TKey, TValue>(this ImmutableSortedDictionary<TKey, TValue>.Builder builder);
+        public static ImmutableSortedDictionary<TKey, TValue> ToImmutableSortedDictionary<TKey, TValue>(this IEnumerable<KeyValuePair<TKey, TValue>> source);
+        public static ImmutableSortedDictionary<TKey, TValue> ToImmutableSortedDictionary<TKey, TValue>(this IEnumerable<KeyValuePair<TKey, TValue>> source, IComparer<TKey> keyComparer);
+        public static ImmutableSortedDictionary<TKey, TValue> ToImmutableSortedDictionary<TKey, TValue>(this IEnumerable<KeyValuePair<TKey, TValue>> source, IComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer);
+        public static ImmutableSortedDictionary<TKey, TValue> ToImmutableSortedDictionary<TSource, TKey, TValue>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TValue> elementSelector);
+        public static ImmutableSortedDictionary<TKey, TValue> ToImmutableSortedDictionary<TSource, TKey, TValue>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TValue> elementSelector, IComparer<TKey> keyComparer);
+        public static ImmutableSortedDictionary<TKey, TValue> ToImmutableSortedDictionary<TSource, TKey, TValue>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TValue> elementSelector, IComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer);
+    }
+    public sealed class ImmutableSortedDictionary<TKey, TValue> : ICollection, ICollection<KeyValuePair<TKey, TValue>>, IDictionary, IDictionary<TKey, TValue>, IEnumerable, IEnumerable<KeyValuePair<TKey, TValue>>, IImmutableDictionary<TKey, TValue>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IReadOnlyDictionary<TKey, TValue> {
+        public static readonly ImmutableSortedDictionary<TKey, TValue> Empty;
+        public int Count { get; }
+        public bool IsEmpty { get; }
+        public IComparer<TKey> KeyComparer { get; }
+        public IEnumerable<TKey> Keys { get; }
+        bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.IsReadOnly { get; }
+        TValue System.Collections.Generic.IDictionary<TKey,TValue>.this[TKey key] { get; set; }
+        ICollection<TKey> System.Collections.Generic.IDictionary<TKey,TValue>.Keys { get; }
+        ICollection<TValue> System.Collections.Generic.IDictionary<TKey,TValue>.Values { get; }
+        bool System.Collections.ICollection.IsSynchronized { get; }
+        object System.Collections.ICollection.SyncRoot { get; }
+        bool System.Collections.IDictionary.IsFixedSize { get; }
+        bool System.Collections.IDictionary.IsReadOnly { get; }
+        object System.Collections.IDictionary.this[object key] { get; set; }
+        ICollection System.Collections.IDictionary.Keys { get; }
+        ICollection System.Collections.IDictionary.Values { get; }
+        public TValue this[TKey key] { get; }
+        public IEqualityComparer<TValue> ValueComparer { get; }
+        public IEnumerable<TValue> Values { get; }
+        public ImmutableSortedDictionary<TKey, TValue> Add(TKey key, TValue value);
+        public ImmutableSortedDictionary<TKey, TValue> AddRange(IEnumerable<KeyValuePair<TKey, TValue>> items);
+        public ImmutableSortedDictionary<TKey, TValue> Clear();
+        public bool Contains(KeyValuePair<TKey, TValue> pair);
+        public bool ContainsKey(TKey key);
+        public bool ContainsValue(TValue value);
+        public ImmutableSortedDictionary<TKey, TValue>.Enumerator GetEnumerator();
+        public ImmutableSortedDictionary<TKey, TValue> Remove(TKey value);
+        public ImmutableSortedDictionary<TKey, TValue> RemoveRange(IEnumerable<TKey> keys);
+        public ImmutableSortedDictionary<TKey, TValue> SetItem(TKey key, TValue value);
+        public ImmutableSortedDictionary<TKey, TValue> SetItems(IEnumerable<KeyValuePair<TKey, TValue>> items);
+        void System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.Add(KeyValuePair<TKey, TValue> item);
+        void System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.Clear();
+        void System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex);
+        bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.Remove(KeyValuePair<TKey, TValue> item);
+        void System.Collections.Generic.IDictionary<TKey,TValue>.Add(TKey key, TValue value);
+        bool System.Collections.Generic.IDictionary<TKey,TValue>.Remove(TKey key);
+        IEnumerator<KeyValuePair<TKey, TValue>> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey,TValue>>.GetEnumerator();
+        void System.Collections.ICollection.CopyTo(Array array, int index);
+        void System.Collections.IDictionary.Add(object key, object value);
+        void System.Collections.IDictionary.Clear();
+        bool System.Collections.IDictionary.Contains(object key);
+        IDictionaryEnumerator System.Collections.IDictionary.GetEnumerator();
+        void System.Collections.IDictionary.Remove(object key);
+        IEnumerator System.Collections.IEnumerable.GetEnumerator();
+        IImmutableDictionary<TKey, TValue> System.Collections.Immutable.IImmutableDictionary<TKey,TValue>.Add(TKey key, TValue value);
+        IImmutableDictionary<TKey, TValue> System.Collections.Immutable.IImmutableDictionary<TKey,TValue>.AddRange(IEnumerable<KeyValuePair<TKey, TValue>> pairs);
+        IImmutableDictionary<TKey, TValue> System.Collections.Immutable.IImmutableDictionary<TKey,TValue>.Clear();
+        IImmutableDictionary<TKey, TValue> System.Collections.Immutable.IImmutableDictionary<TKey,TValue>.Remove(TKey key);
+        IImmutableDictionary<TKey, TValue> System.Collections.Immutable.IImmutableDictionary<TKey,TValue>.RemoveRange(IEnumerable<TKey> keys);
+        IImmutableDictionary<TKey, TValue> System.Collections.Immutable.IImmutableDictionary<TKey,TValue>.SetItem(TKey key, TValue value);
+        IImmutableDictionary<TKey, TValue> System.Collections.Immutable.IImmutableDictionary<TKey,TValue>.SetItems(IEnumerable<KeyValuePair<TKey, TValue>> items);
+        public ImmutableSortedDictionary<TKey, TValue>.Builder ToBuilder();
+        public bool TryGetKey(TKey equalKey, out TKey actualKey);
+        public bool TryGetValue(TKey key, out TValue value);
+        public ref readonly TValue ValueRef(TKey key);
+        public ImmutableSortedDictionary<TKey, TValue> WithComparers(IComparer<TKey> keyComparer);
+        public ImmutableSortedDictionary<TKey, TValue> WithComparers(IComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer);
+        public sealed class Builder : ICollection, ICollection<KeyValuePair<TKey, TValue>>, IDictionary, IDictionary<TKey, TValue>, IEnumerable, IEnumerable<KeyValuePair<TKey, TValue>>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IReadOnlyDictionary<TKey, TValue> {
+            public int Count { get; }
+            public IComparer<TKey> KeyComparer { get; set; }
+            public IEnumerable<TKey> Keys { get; }
+            bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.IsReadOnly { get; }
+            ICollection<TKey> System.Collections.Generic.IDictionary<TKey,TValue>.Keys { get; }
+            ICollection<TValue> System.Collections.Generic.IDictionary<TKey,TValue>.Values { get; }
+            bool System.Collections.ICollection.IsSynchronized { get; }
+            object System.Collections.ICollection.SyncRoot { get; }
+            bool System.Collections.IDictionary.IsFixedSize { get; }
+            bool System.Collections.IDictionary.IsReadOnly { get; }
+            object System.Collections.IDictionary.this[object key] { get; set; }
+            ICollection System.Collections.IDictionary.Keys { get; }
+            ICollection System.Collections.IDictionary.Values { get; }
+            public TValue this[TKey key] { get; set; }
+            public IEqualityComparer<TValue> ValueComparer { get; set; }
+            public IEnumerable<TValue> Values { get; }
+            public void Add(KeyValuePair<TKey, TValue> item);
+            public void Add(TKey key, TValue value);
+            public void AddRange(IEnumerable<KeyValuePair<TKey, TValue>> items);
+            public void Clear();
+            public bool Contains(KeyValuePair<TKey, TValue> item);
+            public bool ContainsKey(TKey key);
+            public bool ContainsValue(TValue value);
+            public ImmutableSortedDictionary<TKey, TValue>.Enumerator GetEnumerator();
+            public TValue GetValueOrDefault(TKey key);
+            public TValue GetValueOrDefault(TKey key, TValue defaultValue);
+            public bool Remove(KeyValuePair<TKey, TValue> item);
+            public bool Remove(TKey key);
+            public void RemoveRange(IEnumerable<TKey> keys);
+            void System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex);
+            IEnumerator<KeyValuePair<TKey, TValue>> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey,TValue>>.GetEnumerator();
+            void System.Collections.ICollection.CopyTo(Array array, int index);
+            void System.Collections.IDictionary.Add(object key, object value);
+            bool System.Collections.IDictionary.Contains(object key);
+            IDictionaryEnumerator System.Collections.IDictionary.GetEnumerator();
+            void System.Collections.IDictionary.Remove(object key);
+            IEnumerator System.Collections.IEnumerable.GetEnumerator();
+            public ImmutableSortedDictionary<TKey, TValue> ToImmutable();
+            public bool TryGetKey(TKey equalKey, out TKey actualKey);
+            public bool TryGetValue(TKey key, out TValue value);
+            public ref readonly TValue ValueRef(TKey key);
+        }
+        public struct Enumerator : IDisposable, IEnumerator, IEnumerator<KeyValuePair<TKey, TValue>> {
+            public KeyValuePair<TKey, TValue> Current { get; }
+            object System.Collections.IEnumerator.Current { get; }
+            public void Dispose();
+            public bool MoveNext();
+            public void Reset();
+        }
+    }
+    public static class ImmutableSortedSet {
+        public static ImmutableSortedSet<T> Create<T>();
+        public static ImmutableSortedSet<T> Create<T>(IComparer<T> comparer);
+        public static ImmutableSortedSet<T> Create<T>(IComparer<T> comparer, T item);
+        public static ImmutableSortedSet<T> Create<T>(IComparer<T> comparer, params T[] items);
+        public static ImmutableSortedSet<T> Create<T>(T item);
+        public static ImmutableSortedSet<T> Create<T>(params T[] items);
+        public static ImmutableSortedSet<T>.Builder CreateBuilder<T>();
+        public static ImmutableSortedSet<T>.Builder CreateBuilder<T>(IComparer<T> comparer);
+        public static ImmutableSortedSet<T> CreateRange<T>(IComparer<T> comparer, IEnumerable<T> items);
+        public static ImmutableSortedSet<T> CreateRange<T>(IEnumerable<T> items);
+        public static ImmutableSortedSet<TSource> ToImmutableSortedSet<TSource>(this ImmutableSortedSet<TSource>.Builder builder);
+        public static ImmutableSortedSet<TSource> ToImmutableSortedSet<TSource>(this IEnumerable<TSource> source);
+        public static ImmutableSortedSet<TSource> ToImmutableSortedSet<TSource>(this IEnumerable<TSource> source, IComparer<TSource> comparer);
+    }
+    public sealed class ImmutableSortedSet<T> : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IImmutableSet<T>, IList, IList<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, IReadOnlySet<T>, ISet<T> {
+        public static readonly ImmutableSortedSet<T> Empty;
+        public int Count { get; }
+        public bool IsEmpty { get; }
+        public IComparer<T> KeyComparer { get; }
+        public T Max { get; }
+        public T Min { get; }
+        bool System.Collections.Generic.ICollection<T>.IsReadOnly { get; }
+        T System.Collections.Generic.IList<T>.this[int index] { get; set; }
+        bool System.Collections.ICollection.IsSynchronized { get; }
+        object System.Collections.ICollection.SyncRoot { get; }
+        bool System.Collections.IList.IsFixedSize { get; }
+        bool System.Collections.IList.IsReadOnly { get; }
+        object System.Collections.IList.this[int index] { get; set; }
+        public T this[int index] { get; }
+        public ImmutableSortedSet<T> Add(T value);
+        public ImmutableSortedSet<T> Clear();
+        public bool Contains(T value);
+        public ImmutableSortedSet<T> Except(IEnumerable<T> other);
+        public ImmutableSortedSet<T>.Enumerator GetEnumerator();
+        public int IndexOf(T item);
+        public ImmutableSortedSet<T> Intersect(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 ref readonly T ItemRef(int index);
+        public bool Overlaps(IEnumerable<T> other);
+        public ImmutableSortedSet<T> Remove(T value);
+        public IEnumerable<T> Reverse();
+        public bool SetEquals(IEnumerable<T> other);
+        public ImmutableSortedSet<T> SymmetricExcept(IEnumerable<T> other);
+        void System.Collections.Generic.ICollection<T>.Add(T item);
+        void System.Collections.Generic.ICollection<T>.Clear();
+        void System.Collections.Generic.ICollection<T>.CopyTo(T[] array, int arrayIndex);
+        bool System.Collections.Generic.ICollection<T>.Remove(T item);
+        IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator();
+        void System.Collections.Generic.IList<T>.Insert(int index, T item);
+        void System.Collections.Generic.IList<T>.RemoveAt(int index);
+        bool System.Collections.Generic.ISet<T>.Add(T item);
+        void System.Collections.Generic.ISet<T>.ExceptWith(IEnumerable<T> other);
+        void System.Collections.Generic.ISet<T>.IntersectWith(IEnumerable<T> other);
+        void System.Collections.Generic.ISet<T>.SymmetricExceptWith(IEnumerable<T> other);
+        void System.Collections.Generic.ISet<T>.UnionWith(IEnumerable<T> other);
+        void System.Collections.ICollection.CopyTo(Array array, int index);
+        IEnumerator System.Collections.IEnumerable.GetEnumerator();
+        int System.Collections.IList.Add(object value);
+        void System.Collections.IList.Clear();
+        bool System.Collections.IList.Contains(object value);
+        int System.Collections.IList.IndexOf(object value);
+        void System.Collections.IList.Insert(int index, object value);
+        void System.Collections.IList.Remove(object value);
+        void System.Collections.IList.RemoveAt(int index);
+        IImmutableSet<T> System.Collections.Immutable.IImmutableSet<T>.Add(T value);
+        IImmutableSet<T> System.Collections.Immutable.IImmutableSet<T>.Clear();
+        IImmutableSet<T> System.Collections.Immutable.IImmutableSet<T>.Except(IEnumerable<T> other);
+        IImmutableSet<T> System.Collections.Immutable.IImmutableSet<T>.Intersect(IEnumerable<T> other);
+        IImmutableSet<T> System.Collections.Immutable.IImmutableSet<T>.Remove(T value);
+        IImmutableSet<T> System.Collections.Immutable.IImmutableSet<T>.SymmetricExcept(IEnumerable<T> other);
+        IImmutableSet<T> System.Collections.Immutable.IImmutableSet<T>.Union(IEnumerable<T> other);
+        public ImmutableSortedSet<T>.Builder ToBuilder();
+        public bool TryGetValue(T equalValue, out T actualValue);
+        public ImmutableSortedSet<T> Union(IEnumerable<T> other);
+        public ImmutableSortedSet<T> WithComparer(IComparer<T> comparer);
+        public sealed class Builder : ICollection, ICollection<T>, IEnumerable, IEnumerable<T>, IReadOnlyCollection<T>, ISet<T> {
+            public int Count { get; }
+            public IComparer<T> KeyComparer { get; set; }
+            public T Max { get; }
+            public T Min { get; }
+            bool System.Collections.Generic.ICollection<T>.IsReadOnly { get; }
+            bool System.Collections.ICollection.IsSynchronized { get; }
+            object System.Collections.ICollection.SyncRoot { get; }
+            public T this[int index] { get; }
+            public bool Add(T item);
+            public void Clear();
+            public bool Contains(T item);
+            public void ExceptWith(IEnumerable<T> other);
+            public ImmutableSortedSet<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 ref readonly T ItemRef(int index);
+            public bool Overlaps(IEnumerable<T> other);
+            public bool Remove(T item);
+            public IEnumerable<T> Reverse();
+            public bool SetEquals(IEnumerable<T> other);
+            public void SymmetricExceptWith(IEnumerable<T> other);
+            void System.Collections.Generic.ICollection<T>.Add(T item);
+            void System.Collections.Generic.ICollection<T>.CopyTo(T[] array, int arrayIndex);
+            IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator();
+            void System.Collections.ICollection.CopyTo(Array array, int arrayIndex);
+            IEnumerator System.Collections.IEnumerable.GetEnumerator();
+            public ImmutableSortedSet<T> ToImmutable();
+            public bool TryGetValue(T equalValue, out T actualValue);
+            public void UnionWith(IEnumerable<T> other);
+        }
+        public struct Enumerator : IDisposable, IEnumerator, IEnumerator<T> {
+            public T Current { get; }
+            object System.Collections.IEnumerator.Current { get; }
+            public void Dispose();
+            public bool MoveNext();
+            public void Reset();
+        }
+    }
+    public static class ImmutableStack {
+        public static ImmutableStack<T> Create<T>();
+        public static ImmutableStack<T> Create<T>(T item);
+        public static ImmutableStack<T> Create<T>(params T[] items);
+        public static ImmutableStack<T> CreateRange<T>(IEnumerable<T> items);
+        public static IImmutableStack<T> Pop<T>(this IImmutableStack<T> stack, out T value);
+    }
+    public sealed class ImmutableStack<T> : IEnumerable, IEnumerable<T>, IImmutableStack<T> {
+        public static ImmutableStack<T> Empty { get; }
+        public bool IsEmpty { get; }
+        public ImmutableStack<T> Clear();
+        public ImmutableStack<T>.Enumerator GetEnumerator();
+        public T Peek();
+        public ref readonly T PeekRef();
+        public ImmutableStack<T> Pop();
+        public ImmutableStack<T> Pop(out T value);
+        public ImmutableStack<T> Push(T value);
+        IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator();
+        IEnumerator System.Collections.IEnumerable.GetEnumerator();
+        IImmutableStack<T> System.Collections.Immutable.IImmutableStack<T>.Clear();
+        IImmutableStack<T> System.Collections.Immutable.IImmutableStack<T>.Pop();
+        IImmutableStack<T> System.Collections.Immutable.IImmutableStack<T>.Push(T value);
+        public struct Enumerator {
+            public T Current { get; }
+            public bool MoveNext();
+        }
+    }
+}
```