System.Collections.cs

// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// ------------------------------------------------------------------------------
// Changes to this file must follow the https://aka.ms/api-review process.
// ------------------------------------------------------------------------------

#if !BUILDING_CORELIB_REFERENCE
namespace System.Collections
{
 public static partial class StructuralComparisons
 {
 public static System.Collections.IComparer StructuralComparer { get { throw null; } }
 public static System.Collections.IEqualityComparer StructuralEqualityComparer { get { throw null; } }
 }
}
namespace System.Collections.Generic
{
 public sealed partial class LinkedListNode<T>
 {
 public LinkedListNode(T value) { }
 public System.Collections.Generic.LinkedList<T>? List { get { throw null; } }
 public System.Collections.Generic.LinkedListNode<T>? Next { get { throw null; } }
 public System.Collections.Generic.LinkedListNode<T>? Previous { get { throw null; } }
 public T Value { get { throw null; } set { } }
 public ref T ValueRef { get { throw null; } }
 }
 public partial class LinkedList<T> : System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyCollection<T>, System.Collections.ICollection, System.Collections.IEnumerable, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable
 {
 public LinkedList() { }
 public LinkedList(System.Collections.Generic.IEnumerable<T> collection) { }
 [System.ObsoleteAttribute("This API supports obsolete formatter-based serialization. It should not be called or extended by application code.", DiagnosticId = "SYSLIB0051", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
 [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
 protected LinkedList(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
 public int Count { get { throw null; } }
 public System.Collections.Generic.LinkedListNode<T>? First { get { throw null; } }
 public System.Collections.Generic.LinkedListNode<T>? Last { get { throw null; } }
 bool System.Collections.Generic.ICollection<T>.IsReadOnly { get { throw null; } }
 bool System.Collections.ICollection.IsSynchronized { get { throw null; } }
 object System.Collections.ICollection.SyncRoot { get { throw null; } }
 public void AddAfter(System.Collections.Generic.LinkedListNode<T> node, System.Collections.Generic.LinkedListNode<T> newNode) { }
 public System.Collections.Generic.LinkedListNode<T> AddAfter(System.Collections.Generic.LinkedListNode<T> node, T value) { throw null; }
 public void AddBefore(System.Collections.Generic.LinkedListNode<T> node, System.Collections.Generic.LinkedListNode<T> newNode) { }
 public System.Collections.Generic.LinkedListNode<T> AddBefore(System.Collections.Generic.LinkedListNode<T> node, T value) { throw null; }
 public void AddFirst(System.Collections.Generic.LinkedListNode<T> node) { }
 public System.Collections.Generic.LinkedListNode<T> AddFirst(T value) { throw null; }
 public void AddLast(System.Collections.Generic.LinkedListNode<T> node) { }
 public System.Collections.Generic.LinkedListNode<T> AddLast(T value) { throw null; }
 public void Clear() { }
 public bool Contains(T value) { throw null; }
 public void CopyTo(T[] array, int index) { }
 public System.Collections.Generic.LinkedListNode<T>? Find(T value) { throw null; }
 public System.Collections.Generic.LinkedListNode<T>? FindLast(T value) { throw null; }
 public System.Collections.Generic.LinkedList<T>.Enumerator GetEnumerator() { throw null; }
 [System.ObsoleteAttribute("This API supports obsolete formatter-based serialization. It should not be called or extended by application code.", DiagnosticId = "SYSLIB0051", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
 [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
 public virtual void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
 public virtual void OnDeserialization(object? sender) { }
 public void Remove(System.Collections.Generic.LinkedListNode<T> node) { }
 public bool Remove(T value) { throw null; }
 public void RemoveFirst() { }
 public void RemoveLast() { }
 void System.Collections.Generic.ICollection<T>.Add(T value) { }
 System.Collections.Generic.IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator() { throw null; }
 void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
 System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; }
 public partial struct Enumerator : System.Collections.Generic.IEnumerator<T>, System.Collections.IEnumerator, System.IDisposable, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable
 {
 private T _current;
 private object _dummy;
 private int _dummyPrimitive;
 public T Current { get { throw null; } }
 object? System.Collections.IEnumerator.Current { get { throw null; } }
 public void Dispose() { }
 public bool MoveNext() { throw null; }
 void System.Collections.IEnumerator.Reset() { }
 void System.Runtime.Serialization.IDeserializationCallback.OnDeserialization(object? sender) { }
 void System.Runtime.Serialization.ISerializable.GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
 }
 }
 public partial class OrderedDictionary<TKey, TValue> : System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey, TValue>>, System.Collections.Generic.IDictionary<TKey, TValue>, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>, System.Collections.Generic.IList<System.Collections.Generic.KeyValuePair<TKey, TValue>>, System.Collections.Generic.IReadOnlyCollection<System.Collections.Generic.KeyValuePair<TKey, TValue>>, System.Collections.Generic.IReadOnlyDictionary<TKey, TValue>, System.Collections.Generic.IReadOnlyList<System.Collections.Generic.KeyValuePair<TKey, TValue>>, System.Collections.ICollection, System.Collections.IDictionary, System.Collections.IEnumerable, System.Collections.IList where TKey : notnull
 {
 public OrderedDictionary() { }
 public OrderedDictionary(System.Collections.Generic.IDictionary<TKey, TValue> dictionary) { }
 public OrderedDictionary(System.Collections.Generic.IDictionary<TKey, TValue> dictionary, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
 public OrderedDictionary(System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>> collection) { }
 public OrderedDictionary(System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>> collection, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
 public OrderedDictionary(System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
 public OrderedDictionary(int capacity) { }
 public OrderedDictionary(int capacity, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
 public int Capacity { get { throw null; } }
 public System.Collections.Generic.IEqualityComparer<TKey> Comparer { get { throw null; } }
 public int Count { get { throw null; } }
 public TValue this[TKey key] { get { throw null; } set { } }
 public System.Collections.Generic.OrderedDictionary<TKey, TValue>.KeyCollection Keys { get { throw null; } }
 bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey, TValue>>.IsReadOnly { get { throw null; } }
 System.Collections.Generic.ICollection<TKey> System.Collections.Generic.IDictionary<TKey, TValue>.Keys { get { throw null; } }
 System.Collections.Generic.ICollection<TValue> System.Collections.Generic.IDictionary<TKey, TValue>.Values { get { throw null; } }
 System.Collections.Generic.KeyValuePair<TKey, TValue> System.Collections.Generic.IList<System.Collections.Generic.KeyValuePair<TKey, TValue>>.this[int index] { get { throw null; } set { } }
 System.Collections.Generic.IEnumerable<TKey> System.Collections.Generic.IReadOnlyDictionary<TKey, TValue>.Keys { get { throw null; } }
 System.Collections.Generic.IEnumerable<TValue> System.Collections.Generic.IReadOnlyDictionary<TKey, TValue>.Values { get { throw null; } }
 System.Collections.Generic.KeyValuePair<TKey, TValue> System.Collections.Generic.IReadOnlyList<System.Collections.Generic.KeyValuePair<TKey, TValue>>.this[int index] { get { throw null; } }
 bool System.Collections.ICollection.IsSynchronized { get { throw null; } }
 object System.Collections.ICollection.SyncRoot { get { throw null; } }
 bool System.Collections.IDictionary.IsFixedSize { get { throw null; } }
 bool System.Collections.IDictionary.IsReadOnly { get { throw null; } }
 object? System.Collections.IDictionary.this[object key] { get { throw null; } set { } }
 System.Collections.ICollection System.Collections.IDictionary.Keys { get { throw null; } }
 System.Collections.ICollection System.Collections.IDictionary.Values { get { throw null; } }
 bool System.Collections.IList.IsFixedSize { get { throw null; } }
 bool System.Collections.IList.IsReadOnly { get { throw null; } }
 object? System.Collections.IList.this[int index] { get { throw null; } set { } }
 public System.Collections.Generic.OrderedDictionary<TKey, TValue>.ValueCollection Values { get { throw null; } }
 public void Add(TKey key, TValue value) { }
 public void Clear() { }
 public bool ContainsKey(TKey key) { throw null; }
 public bool ContainsValue(TValue value) { throw null; }
 public int EnsureCapacity(int capacity) { throw null; }
 public System.Collections.Generic.KeyValuePair<TKey, TValue> GetAt(int index) { throw null; }
 public System.Collections.Generic.OrderedDictionary<TKey, TValue>.Enumerator GetEnumerator() { throw null; }
 public int IndexOf(TKey key) { throw null; }
 public void Insert(int index, TKey key, TValue value) { }
 public bool Remove(TKey key) { throw null; }
 public bool Remove(TKey key, [System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute(false)] out TValue value) { throw null; }
 public void RemoveAt(int index) { }
 public void SetAt(int index, TKey key, TValue value) { }
 public void SetAt(int index, TValue value) { }
 void System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey, TValue>>.Add(System.Collections.Generic.KeyValuePair<TKey, TValue> item) { }
 bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey, TValue>>.Contains(System.Collections.Generic.KeyValuePair<TKey, TValue> item) { throw null; }
 void System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey, TValue>>.CopyTo(System.Collections.Generic.KeyValuePair<TKey, TValue>[] array, int arrayIndex) { }
 bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey, TValue>>.Remove(System.Collections.Generic.KeyValuePair<TKey, TValue> item) { throw null; }
 System.Collections.Generic.IEnumerator<System.Collections.Generic.KeyValuePair<TKey, TValue>> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>.GetEnumerator() { throw null; }
 int System.Collections.Generic.IList<System.Collections.Generic.KeyValuePair<TKey, TValue>>.IndexOf(System.Collections.Generic.KeyValuePair<TKey, TValue> item) { throw null; }
 void System.Collections.Generic.IList<System.Collections.Generic.KeyValuePair<TKey, TValue>>.Insert(int index, System.Collections.Generic.KeyValuePair<TKey, TValue> item) { }
 void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
 void System.Collections.IDictionary.Add(object key, object? value) { }
 bool System.Collections.IDictionary.Contains(object key) { throw null; }
 System.Collections.IDictionaryEnumerator System.Collections.IDictionary.GetEnumerator() { throw null; }
 void System.Collections.IDictionary.Remove(object key) { }
 System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; }
 int System.Collections.IList.Add(object? value) { throw null; }
 bool System.Collections.IList.Contains(object? value) { throw null; }
 int System.Collections.IList.IndexOf(object? value) { throw null; }
 void System.Collections.IList.Insert(int index, object? value) { }
 void System.Collections.IList.Remove(object? value) { }
 public void TrimExcess() { }
 public void TrimExcess(int capacity) { }
 public bool TryAdd(TKey key, TValue value) { throw null; }
 public bool TryAdd(TKey key, TValue value, out int index) { throw null; }
 public bool TryGetValue(TKey key, [System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute(false)] out TValue value) { throw null; }
 public bool TryGetValue(TKey key, [System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute(false)] out TValue value, out int index) { throw null; }
 public partial struct Enumerator : System.Collections.Generic.IEnumerator<System.Collections.Generic.KeyValuePair<TKey, TValue>>, System.Collections.IDictionaryEnumerator, System.Collections.IEnumerator, System.IDisposable
 {
 private object _dummy;
 private int _dummyPrimitive;
 public readonly System.Collections.Generic.KeyValuePair<TKey, TValue> Current { get { throw null; } }
 System.Collections.DictionaryEntry System.Collections.IDictionaryEnumerator.Entry { get { throw null; } }
 object System.Collections.IDictionaryEnumerator.Key { get { throw null; } }
 object? System.Collections.IDictionaryEnumerator.Value { get { throw null; } }
 object System.Collections.IEnumerator.Current { get { throw null; } }
 public bool MoveNext() { throw null; }
 void System.Collections.IEnumerator.Reset() { }
 void System.IDisposable.Dispose() { }
 }
 public sealed partial class KeyCollection : System.Collections.Generic.ICollection<TKey>, System.Collections.Generic.IEnumerable<TKey>, System.Collections.Generic.IList<TKey>, System.Collections.Generic.IReadOnlyCollection<TKey>, System.Collections.Generic.IReadOnlyList<TKey>, System.Collections.ICollection, System.Collections.IEnumerable, System.Collections.IList
 {
 internal KeyCollection() { }
 public int Count { get { throw null; } }
 bool System.Collections.Generic.ICollection<TKey>.IsReadOnly { get { throw null; } }
 TKey System.Collections.Generic.IList<TKey>.this[int index] { get { throw null; } set { } }
 TKey System.Collections.Generic.IReadOnlyList<TKey>.this[int index] { get { throw null; } }
 bool System.Collections.ICollection.IsSynchronized { get { throw null; } }
 object System.Collections.ICollection.SyncRoot { get { throw null; } }
 bool System.Collections.IList.IsFixedSize { get { throw null; } }
 bool System.Collections.IList.IsReadOnly { get { throw null; } }
 object? System.Collections.IList.this[int index] { get { throw null; } set { } }
 public bool Contains(TKey key) { throw null; }
 public void CopyTo(TKey[] array, int arrayIndex) { }
 public System.Collections.Generic.OrderedDictionary<TKey, TValue>.KeyCollection.Enumerator GetEnumerator() { throw null; }
 void System.Collections.Generic.ICollection<TKey>.Add(TKey item) { }
 void System.Collections.Generic.ICollection<TKey>.Clear() { }
 bool System.Collections.Generic.ICollection<TKey>.Remove(TKey item) { throw null; }
 System.Collections.Generic.IEnumerator<TKey> System.Collections.Generic.IEnumerable<TKey>.GetEnumerator() { throw null; }
 int System.Collections.Generic.IList<TKey>.IndexOf(TKey item) { throw null; }
 void System.Collections.Generic.IList<TKey>.Insert(int index, TKey item) { }
 void System.Collections.Generic.IList<TKey>.RemoveAt(int index) { }
 void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
 System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; }
 int System.Collections.IList.Add(object? value) { throw null; }
 void System.Collections.IList.Clear() { }
 bool System.Collections.IList.Contains(object? value) { throw null; }
 int System.Collections.IList.IndexOf(object? value) { throw null; }
 void System.Collections.IList.Insert(int index, object? value) { }
 void System.Collections.IList.Remove(object? value) { }
 void System.Collections.IList.RemoveAt(int index) { }
 public partial struct Enumerator : System.Collections.Generic.IEnumerator<TKey>, System.Collections.IEnumerator, System.IDisposable
 {
 private TKey _Current_k__BackingField;
 private object _dummy;
 private int _dummyPrimitive;
 public readonly TKey Current { get { throw null; } }
 object System.Collections.IEnumerator.Current { get { throw null; } }
 public bool MoveNext() { throw null; }
 void System.Collections.IEnumerator.Reset() { }
 void System.IDisposable.Dispose() { }
 }
 }
 public sealed partial class ValueCollection : System.Collections.Generic.ICollection<TValue>, System.Collections.Generic.IEnumerable<TValue>, System.Collections.Generic.IList<TValue>, System.Collections.Generic.IReadOnlyCollection<TValue>, System.Collections.Generic.IReadOnlyList<TValue>, System.Collections.ICollection, System.Collections.IEnumerable, System.Collections.IList
 {
 internal ValueCollection() { }
 public int Count { get { throw null; } }
 bool System.Collections.Generic.ICollection<TValue>.IsReadOnly { get { throw null; } }
 TValue System.Collections.Generic.IList<TValue>.this[int index] { get { throw null; } set { } }
 TValue System.Collections.Generic.IReadOnlyList<TValue>.this[int index] { get { throw null; } }
 bool System.Collections.ICollection.IsSynchronized { get { throw null; } }
 object System.Collections.ICollection.SyncRoot { get { throw null; } }
 bool System.Collections.IList.IsFixedSize { get { throw null; } }
 bool System.Collections.IList.IsReadOnly { get { throw null; } }
 object? System.Collections.IList.this[int index] { get { throw null; } set { } }
 public void CopyTo(TValue[] array, int arrayIndex) { }
 public System.Collections.Generic.OrderedDictionary<TKey, TValue>.ValueCollection.Enumerator GetEnumerator() { throw null; }
 void System.Collections.Generic.ICollection<TValue>.Add(TValue item) { }
 void System.Collections.Generic.ICollection<TValue>.Clear() { }
 bool System.Collections.Generic.ICollection<TValue>.Contains(TValue item) { throw null; }
 bool System.Collections.Generic.ICollection<TValue>.Remove(TValue item) { throw null; }
 System.Collections.Generic.IEnumerator<TValue> System.Collections.Generic.IEnumerable<TValue>.GetEnumerator() { throw null; }
 int System.Collections.Generic.IList<TValue>.IndexOf(TValue item) { throw null; }
 void System.Collections.Generic.IList<TValue>.Insert(int index, TValue item) { }
 void System.Collections.Generic.IList<TValue>.RemoveAt(int index) { }
 void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
 System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; }
 int System.Collections.IList.Add(object? value) { throw null; }
 void System.Collections.IList.Clear() { }
 bool System.Collections.IList.Contains(object? value) { throw null; }
 int System.Collections.IList.IndexOf(object? value) { throw null; }
 void System.Collections.IList.Insert(int index, object? value) { }
 void System.Collections.IList.Remove(object? value) { }
 void System.Collections.IList.RemoveAt(int index) { }
 public partial struct Enumerator : System.Collections.Generic.IEnumerator<TValue>, System.Collections.IEnumerator, System.IDisposable
 {
 private TValue _Current_k__BackingField;
 private object _dummy;
 private int _dummyPrimitive;
 public readonly TValue Current { get { throw null; } }
 object? System.Collections.IEnumerator.Current { get { throw null; } }
 public bool MoveNext() { throw null; }
 void System.Collections.IEnumerator.Reset() { }
 void System.IDisposable.Dispose() { }
 }
 }
 }
 public partial class PriorityQueue<TElement, TPriority>
 {
 public PriorityQueue() { }
 public PriorityQueue(System.Collections.Generic.IComparer<TPriority>? comparer) { }
 public PriorityQueue(System.Collections.Generic.IEnumerable<(TElement Element, TPriority Priority)> items) { }
 public PriorityQueue(System.Collections.Generic.IEnumerable<(TElement Element, TPriority Priority)> items, System.Collections.Generic.IComparer<TPriority>? comparer) { }
 public PriorityQueue(int initialCapacity) { }
 public PriorityQueue(int initialCapacity, System.Collections.Generic.IComparer<TPriority>? comparer) { }
 public System.Collections.Generic.IComparer<TPriority> Comparer { get { throw null; } }
 public int Count { get { throw null; } }
 public int Capacity { get { throw null; } }
 public System.Collections.Generic.PriorityQueue<TElement, TPriority>.UnorderedItemsCollection UnorderedItems { get { throw null; } }
 public void Clear() { }
 public TElement Dequeue() { throw null; }
 public TElement DequeueEnqueue(TElement element, TPriority priority) { throw null; }
 public void Enqueue(TElement element, TPriority priority) { }
 public TElement EnqueueDequeue(TElement element, TPriority priority) { throw null; }
 public void EnqueueRange(System.Collections.Generic.IEnumerable<(TElement Element, TPriority Priority)> items) { }
 public void EnqueueRange(System.Collections.Generic.IEnumerable<TElement> elements, TPriority priority) { }
 public int EnsureCapacity(int capacity) { throw null; }
 public TElement Peek() { throw null; }
 public bool Remove(TElement element, [System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute(false)] out TElement removedElement, [System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute(false)] out TPriority priority, System.Collections.Generic.IEqualityComparer<TElement>? equalityComparer = null) { throw null; }
 public void TrimExcess() { }
 public bool TryDequeue([System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute(false)] out TElement element, [System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute(false)] out TPriority priority) { throw null; }
 public bool TryPeek([System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute(false)] out TElement element, [System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute(false)] out TPriority priority) { throw null; }
 public sealed partial class UnorderedItemsCollection : System.Collections.Generic.IEnumerable<(TElement Element, TPriority Priority)>, System.Collections.Generic.IReadOnlyCollection<(TElement Element, TPriority Priority)>, System.Collections.ICollection, System.Collections.IEnumerable
 {
 internal UnorderedItemsCollection(PriorityQueue<TElement, TPriority> queue) { }
 public int Count { get { throw null; } }
 bool System.Collections.ICollection.IsSynchronized { get { throw null; } }
 object System.Collections.ICollection.SyncRoot { get { throw null; } }
 void ICollection.CopyTo(System.Array array, int index) { }
 public System.Collections.Generic.PriorityQueue<TElement, TPriority>.UnorderedItemsCollection.Enumerator GetEnumerator() { throw null; }
 System.Collections.Generic.IEnumerator<(TElement Element, TPriority Priority)> System.Collections.Generic.IEnumerable<(TElement Element, TPriority Priority)>.GetEnumerator() { throw null; }
 System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; }
 public partial struct Enumerator : System.Collections.Generic.IEnumerator<(TElement Element, TPriority Priority)>, System.Collections.IEnumerator, System.IDisposable
 {
 (TElement Element, TPriority Priority) IEnumerator<(TElement Element, TPriority Priority)>.Current { get { throw null; } }
 public void Dispose() { }
 public bool MoveNext() { throw null; }
 public (TElement Element, TPriority Priority) Current { get { throw null; } }
 object System.Collections.IEnumerator.Current { get { throw null; } }
 void System.Collections.IEnumerator.Reset() { }
 }
 }
 }
 public partial class SortedDictionary<TKey, TValue> : System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey, TValue>>, System.Collections.Generic.IDictionary<TKey, TValue>, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>, System.Collections.Generic.IReadOnlyCollection<System.Collections.Generic.KeyValuePair<TKey, TValue>>, System.Collections.Generic.IReadOnlyDictionary<TKey, TValue>, System.Collections.ICollection, System.Collections.IDictionary, System.Collections.IEnumerable where TKey : notnull
 {
 public SortedDictionary() { }
 public SortedDictionary(System.Collections.Generic.IComparer<TKey>? comparer) { }
 public SortedDictionary(System.Collections.Generic.IDictionary<TKey, TValue> dictionary) { }
 public SortedDictionary(System.Collections.Generic.IDictionary<TKey, TValue> dictionary, System.Collections.Generic.IComparer<TKey>? comparer) { }
 public System.Collections.Generic.IComparer<TKey> Comparer { get { throw null; } }
 public int Count { get { throw null; } }
 public TValue this[TKey key] { get { throw null; } set { } }
 public System.Collections.Generic.SortedDictionary<TKey, TValue>.KeyCollection Keys { get { throw null; } }
 bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey, TValue>>.IsReadOnly { get { throw null; } }
 System.Collections.Generic.ICollection<TKey> System.Collections.Generic.IDictionary<TKey, TValue>.Keys { get { throw null; } }
 System.Collections.Generic.ICollection<TValue> System.Collections.Generic.IDictionary<TKey, TValue>.Values { get { throw null; } }
 System.Collections.Generic.IEnumerable<TKey> System.Collections.Generic.IReadOnlyDictionary<TKey, TValue>.Keys { get { throw null; } }
 System.Collections.Generic.IEnumerable<TValue> System.Collections.Generic.IReadOnlyDictionary<TKey, TValue>.Values { get { throw null; } }
 bool System.Collections.ICollection.IsSynchronized { get { throw null; } }
 object System.Collections.ICollection.SyncRoot { get { throw null; } }
 bool System.Collections.IDictionary.IsFixedSize { get { throw null; } }
 bool System.Collections.IDictionary.IsReadOnly { get { throw null; } }
 object? System.Collections.IDictionary.this[object key] { get { throw null; } set { } }
 System.Collections.ICollection System.Collections.IDictionary.Keys { get { throw null; } }
 System.Collections.ICollection System.Collections.IDictionary.Values { get { throw null; } }
 public System.Collections.Generic.SortedDictionary<TKey, TValue>.ValueCollection Values { get { throw null; } }
 public void Add(TKey key, TValue value) { }
 public void Clear() { }
 public bool ContainsKey(TKey key) { throw null; }
 public bool ContainsValue(TValue value) { throw null; }
 public void CopyTo(System.Collections.Generic.KeyValuePair<TKey, TValue>[] array, int index) { }
 public System.Collections.Generic.SortedDictionary<TKey, TValue>.Enumerator GetEnumerator() { throw null; }
 public bool Remove(TKey key) { throw null; }
 void System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey, TValue>>.Add(System.Collections.Generic.KeyValuePair<TKey, TValue> keyValuePair) { }
 bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey, TValue>>.Contains(System.Collections.Generic.KeyValuePair<TKey, TValue> keyValuePair) { throw null; }
 bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey, TValue>>.Remove(System.Collections.Generic.KeyValuePair<TKey, TValue> keyValuePair) { throw null; }
 System.Collections.Generic.IEnumerator<System.Collections.Generic.KeyValuePair<TKey, TValue>> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>.GetEnumerator() { throw null; }
 void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
 void System.Collections.IDictionary.Add(object key, object? value) { }
 bool System.Collections.IDictionary.Contains(object key) { throw null; }
 System.Collections.IDictionaryEnumerator System.Collections.IDictionary.GetEnumerator() { throw null; }
 void System.Collections.IDictionary.Remove(object key) { }
 System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; }
 public bool TryGetValue(TKey key, [System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute(false)] out TValue value) { throw null; }
 public partial struct Enumerator : System.Collections.Generic.IEnumerator<System.Collections.Generic.KeyValuePair<TKey, TValue>>, System.Collections.IDictionaryEnumerator, System.Collections.IEnumerator, System.IDisposable
 {
 private object _dummy;
 private int _dummyPrimitive;
 public System.Collections.Generic.KeyValuePair<TKey, TValue> Current { get { throw null; } }
 System.Collections.DictionaryEntry System.Collections.IDictionaryEnumerator.Entry { get { throw null; } }
 object System.Collections.IDictionaryEnumerator.Key { get { throw null; } }
 object? System.Collections.IDictionaryEnumerator.Value { get { throw null; } }
 object? System.Collections.IEnumerator.Current { get { throw null; } }
 public void Dispose() { }
 public bool MoveNext() { throw null; }
 void System.Collections.IEnumerator.Reset() { }
 }
 public sealed partial class KeyCollection : System.Collections.Generic.ICollection<TKey>, System.Collections.Generic.IEnumerable<TKey>, System.Collections.Generic.IReadOnlyCollection<TKey>, System.Collections.ICollection, System.Collections.IEnumerable
 {
 public KeyCollection(System.Collections.Generic.SortedDictionary<TKey, TValue> dictionary) { }
 public int Count { get { throw null; } }
 bool System.Collections.Generic.ICollection<TKey>.IsReadOnly { get { throw null; } }
 bool System.Collections.ICollection.IsSynchronized { get { throw null; } }
 object System.Collections.ICollection.SyncRoot { get { throw null; } }
 public void CopyTo(TKey[] array, int index) { }
 public System.Collections.Generic.SortedDictionary<TKey, TValue>.KeyCollection.Enumerator GetEnumerator() { throw null; }
 void System.Collections.Generic.ICollection<TKey>.Add(TKey item) { }
 void System.Collections.Generic.ICollection<TKey>.Clear() { }
 public bool Contains(TKey item) { throw null; }
 bool System.Collections.Generic.ICollection<TKey>.Remove(TKey item) { throw null; }
 System.Collections.Generic.IEnumerator<TKey> System.Collections.Generic.IEnumerable<TKey>.GetEnumerator() { throw null; }
 void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
 System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; }
 public partial struct Enumerator : System.Collections.Generic.IEnumerator<TKey>, System.Collections.IEnumerator, System.IDisposable
 {
 private object _dummy;
 private int _dummyPrimitive;
 public TKey Current { get { throw null; } }
 object? System.Collections.IEnumerator.Current { get { throw null; } }
 public void Dispose() { }
 public bool MoveNext() { throw null; }
 void System.Collections.IEnumerator.Reset() { }
 }
 }
 public sealed partial class ValueCollection : System.Collections.Generic.ICollection<TValue>, System.Collections.Generic.IEnumerable<TValue>, System.Collections.Generic.IReadOnlyCollection<TValue>, System.Collections.ICollection, System.Collections.IEnumerable
 {
 public ValueCollection(System.Collections.Generic.SortedDictionary<TKey, TValue> dictionary) { }
 public int Count { get { throw null; } }
 bool System.Collections.Generic.ICollection<TValue>.IsReadOnly { get { throw null; } }
 bool System.Collections.ICollection.IsSynchronized { get { throw null; } }
 object System.Collections.ICollection.SyncRoot { get { throw null; } }
 public void CopyTo(TValue[] array, int index) { }
 public System.Collections.Generic.SortedDictionary<TKey, TValue>.ValueCollection.Enumerator GetEnumerator() { throw null; }
 void System.Collections.Generic.ICollection<TValue>.Add(TValue item) { }
 void System.Collections.Generic.ICollection<TValue>.Clear() { }
 bool System.Collections.Generic.ICollection<TValue>.Contains(TValue item) { throw null; }
 bool System.Collections.Generic.ICollection<TValue>.Remove(TValue item) { throw null; }
 System.Collections.Generic.IEnumerator<TValue> System.Collections.Generic.IEnumerable<TValue>.GetEnumerator() { throw null; }
 void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
 System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; }
 public partial struct Enumerator : System.Collections.Generic.IEnumerator<TValue>, System.Collections.IEnumerator, System.IDisposable
 {
 private object _dummy;
 private int _dummyPrimitive;
 public TValue Current { get { throw null; } }
 object? System.Collections.IEnumerator.Current { get { throw null; } }
 public void Dispose() { }
 public bool MoveNext() { throw null; }
 void System.Collections.IEnumerator.Reset() { }
 }
 }
 }
 public partial class SortedList<TKey, TValue> : System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey, TValue>>, System.Collections.Generic.IDictionary<TKey, TValue>, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>, System.Collections.Generic.IReadOnlyCollection<System.Collections.Generic.KeyValuePair<TKey, TValue>>, System.Collections.Generic.IReadOnlyDictionary<TKey, TValue>, System.Collections.ICollection, System.Collections.IDictionary, System.Collections.IEnumerable where TKey : notnull
 {
 public SortedList() { }
 public SortedList(System.Collections.Generic.IComparer<TKey>? comparer) { }
 public SortedList(System.Collections.Generic.IDictionary<TKey, TValue> dictionary) { }
 public SortedList(System.Collections.Generic.IDictionary<TKey, TValue> dictionary, System.Collections.Generic.IComparer<TKey>? comparer) { }
 public SortedList(int capacity) { }
 public SortedList(int capacity, System.Collections.Generic.IComparer<TKey>? comparer) { }
 public int Capacity { get { throw null; } set { } }
 public System.Collections.Generic.IComparer<TKey> Comparer { get { throw null; } }
 public int Count { get { throw null; } }
 public TValue this[TKey key] { get { throw null; } set { } }
 public System.Collections.Generic.IList<TKey> Keys { get { throw null; } }
 bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey, TValue>>.IsReadOnly { get { throw null; } }
 System.Collections.Generic.ICollection<TKey> System.Collections.Generic.IDictionary<TKey, TValue>.Keys { get { throw null; } }
 System.Collections.Generic.ICollection<TValue> System.Collections.Generic.IDictionary<TKey, TValue>.Values { get { throw null; } }
 System.Collections.Generic.IEnumerable<TKey> System.Collections.Generic.IReadOnlyDictionary<TKey, TValue>.Keys { get { throw null; } }
 System.Collections.Generic.IEnumerable<TValue> System.Collections.Generic.IReadOnlyDictionary<TKey, TValue>.Values { get { throw null; } }
 bool System.Collections.ICollection.IsSynchronized { get { throw null; } }
 object System.Collections.ICollection.SyncRoot { get { throw null; } }
 bool System.Collections.IDictionary.IsFixedSize { get { throw null; } }
 bool System.Collections.IDictionary.IsReadOnly { get { throw null; } }
 object? System.Collections.IDictionary.this[object key] { get { throw null; } set { } }
 System.Collections.ICollection System.Collections.IDictionary.Keys { get { throw null; } }
 System.Collections.ICollection System.Collections.IDictionary.Values { get { throw null; } }
 public System.Collections.Generic.IList<TValue> Values { get { throw null; } }
 public void Add(TKey key, TValue value) { }
 public void Clear() { }
 public bool ContainsKey(TKey key) { throw null; }
 public bool ContainsValue(TValue value) { throw null; }
 public System.Collections.Generic.IEnumerator<System.Collections.Generic.KeyValuePair<TKey, TValue>> GetEnumerator() { throw null; }
 public TKey GetKeyAtIndex(int index) { throw null; }
 public TValue GetValueAtIndex(int index) { throw null; }
 public int IndexOfKey(TKey key) { throw null; }
 public int IndexOfValue(TValue value) { throw null; }
 public bool Remove(TKey key) { throw null; }
 public void RemoveAt(int index) { }
 public void SetValueAtIndex(int index, TValue value) { }
 void System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey, TValue>>.Add(System.Collections.Generic.KeyValuePair<TKey, TValue> keyValuePair) { }
 bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey, TValue>>.Contains(System.Collections.Generic.KeyValuePair<TKey, TValue> keyValuePair) { throw null; }
 void System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey, TValue>>.CopyTo(System.Collections.Generic.KeyValuePair<TKey, TValue>[] array, int arrayIndex) { }
 bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey, TValue>>.Remove(System.Collections.Generic.KeyValuePair<TKey, TValue> keyValuePair) { throw null; }
 System.Collections.Generic.IEnumerator<System.Collections.Generic.KeyValuePair<TKey, TValue>> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>.GetEnumerator() { throw null; }
 void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
 void System.Collections.IDictionary.Add(object key, object? value) { }
 bool System.Collections.IDictionary.Contains(object key) { throw null; }
 System.Collections.IDictionaryEnumerator System.Collections.IDictionary.GetEnumerator() { throw null; }
 void System.Collections.IDictionary.Remove(object key) { }
 System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; }
 public void TrimExcess() { }
 public bool TryGetValue(TKey key, [System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute(false)] out TValue value) { throw null; }
 }
 public partial class SortedSet<T> : System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyCollection<T>, System.Collections.Generic.ISet<T>, System.Collections.Generic.IReadOnlySet<T>, System.Collections.ICollection, System.Collections.IEnumerable, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable
 {
 public SortedSet() { }
 public SortedSet(System.Collections.Generic.IComparer<T>? comparer) { }
 public SortedSet(System.Collections.Generic.IEnumerable<T> collection) { }
 public SortedSet(System.Collections.Generic.IEnumerable<T> collection, System.Collections.Generic.IComparer<T>? comparer) { }
 [System.ObsoleteAttribute("This API supports obsolete formatter-based serialization. It should not be called or extended by application code.", DiagnosticId = "SYSLIB0051", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
 [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
 protected SortedSet(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
 public System.Collections.Generic.IComparer<T> Comparer { get { throw null; } }
 public int Count { get { throw null; } }
 public T? Max { get { throw null; } }
 public T? Min { get { throw null; } }
 bool System.Collections.Generic.ICollection<T>.IsReadOnly { get { throw null; } }
 bool System.Collections.ICollection.IsSynchronized { get { throw null; } }
 object System.Collections.ICollection.SyncRoot { get { throw null; } }
 public bool Add(T item) { throw null; }
 public virtual void Clear() { }
 public virtual bool Contains(T item) { throw null; }
 public void CopyTo(T[] array) { }
 public void CopyTo(T[] array, int index) { }
 public void CopyTo(T[] array, int index, int count) { }
 public static System.Collections.Generic.IEqualityComparer<System.Collections.Generic.SortedSet<T>> CreateSetComparer() { throw null; }
 public static System.Collections.Generic.IEqualityComparer<System.Collections.Generic.SortedSet<T>> CreateSetComparer(System.Collections.Generic.IEqualityComparer<T>? memberEqualityComparer) { throw null; }
 public void ExceptWith(System.Collections.Generic.IEnumerable<T> other) { }
 public System.Collections.Generic.SortedSet<T>.Enumerator GetEnumerator() { throw null; }
 protected virtual void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
 public virtual System.Collections.Generic.SortedSet<T> GetViewBetween(T? lowerValue, T? upperValue) { throw null; }
 public virtual void IntersectWith(System.Collections.Generic.IEnumerable<T> other) { }
 public bool IsProperSubsetOf(System.Collections.Generic.IEnumerable<T> other) { throw null; }
 public bool IsProperSupersetOf(System.Collections.Generic.IEnumerable<T> other) { throw null; }
 public bool IsSubsetOf(System.Collections.Generic.IEnumerable<T> other) { throw null; }
 public bool IsSupersetOf(System.Collections.Generic.IEnumerable<T> other) { throw null; }
 protected virtual void OnDeserialization(object? sender) { }
 public bool Overlaps(System.Collections.Generic.IEnumerable<T> other) { throw null; }
 public bool Remove(T item) { throw null; }
 public int RemoveWhere(System.Predicate<T> match) { throw null; }
 public System.Collections.Generic.IEnumerable<T> Reverse() { throw null; }
 public bool SetEquals(System.Collections.Generic.IEnumerable<T> other) { throw null; }
 public void SymmetricExceptWith(System.Collections.Generic.IEnumerable<T> other) { }
 void System.Collections.Generic.ICollection<T>.Add(T item) { }
 System.Collections.Generic.IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator() { throw null; }
 void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
 System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; }
 void System.Runtime.Serialization.IDeserializationCallback.OnDeserialization(object? sender) { }
 void System.Runtime.Serialization.ISerializable.GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
 public bool TryGetValue(T equalValue, [System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute(false)] out T actualValue) { throw null; }
 public void UnionWith(System.Collections.Generic.IEnumerable<T> other) { }
 public partial struct Enumerator : System.Collections.Generic.IEnumerator<T>, System.Collections.IEnumerator, System.IDisposable, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable
 {
 private object _dummy;
 private int _dummyPrimitive;
 public T Current { get { throw null; } }
 object? System.Collections.IEnumerator.Current { get { throw null; } }
 public void Dispose() { }
 public bool MoveNext() { throw null; }
 void System.Collections.IEnumerator.Reset() { }
 void System.Runtime.Serialization.IDeserializationCallback.OnDeserialization(object? sender) { }
 void System.Runtime.Serialization.ISerializable.GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
 }
 }
 public partial class Stack<T> : System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyCollection<T>, System.Collections.ICollection, System.Collections.IEnumerable
 {
 public Stack() { }
 public Stack(System.Collections.Generic.IEnumerable<T> collection) { }
 public Stack(int capacity) { }
 public int Count { get { throw null; } }
 public int Capacity { get { throw null; } }
 bool System.Collections.ICollection.IsSynchronized { get { throw null; } }
 object System.Collections.ICollection.SyncRoot { get { throw null; } }
 public void Clear() { }
 public bool Contains(T item) { throw null; }
 public void CopyTo(T[] array, int arrayIndex) { }
 public System.Collections.Generic.Stack<T>.Enumerator GetEnumerator() { throw null; }
 public T Peek() { throw null; }
 public T Pop() { throw null; }
 public void Push(T item) { }
 System.Collections.Generic.IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator() { throw null; }
 void System.Collections.ICollection.CopyTo(System.Array array, int arrayIndex) { }
 System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; }
 public int EnsureCapacity(int capacity) { throw null; }
 public T[] ToArray() { throw null; }
 public void TrimExcess() { }
 public void TrimExcess(int capacity) { }
 public bool TryPeek([System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute(false)] out T result) { throw null; }
 public bool TryPop([System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute(false)] out T result) { throw null; }
 public partial struct Enumerator : System.Collections.Generic.IEnumerator<T>, System.Collections.IEnumerator, System.IDisposable
 {
 private T _currentElement;
 private object _dummy;
 private int _dummyPrimitive;
 public T Current { get { throw null; } }
 object? System.Collections.IEnumerator.Current { get { throw null; } }
 public void Dispose() { }
 public bool MoveNext() { throw null; }
 void System.Collections.IEnumerator.Reset() { }
 }
 }
}
#endif // !BUILDING_CORELIB_REFERENCE
namespace System.Collections
{
 public sealed partial class BitArray : System.Collections.ICollection, System.Collections.IEnumerable, System.ICloneable
 {
 public BitArray(bool[] values) { }
 public BitArray(byte[] bytes) { }
 public BitArray(System.Collections.BitArray bits) { }
 public BitArray(int length) { }
 public BitArray(int length, bool defaultValue) { }
 public BitArray(int[] values) { }
 public BitArray(System.ReadOnlySpan<bool> values) { }
 public BitArray(System.ReadOnlySpan<byte> bytes) { }
 public BitArray(System.ReadOnlySpan<int> values) { }
 public int Count { get { throw null; } }
 public bool IsReadOnly { get { throw null; } }
 public bool IsSynchronized { get { throw null; } }
 public bool this[int index] { get { throw null; } set { } }
 public int Length { get { throw null; } set { } }
 public object SyncRoot { get { throw null; } }
 public System.Collections.BitArray And(System.Collections.BitArray value) { throw null; }
 public object Clone() { throw null; }
 public void CopyTo(System.Array array, int index) { }
 public bool Get(int index) { throw null; }
 public System.Collections.IEnumerator GetEnumerator() { throw null; }
 public bool HasAllSet() { throw null; }
 public bool HasAnySet() { throw null; }
 public System.Collections.BitArray LeftShift(int count) { throw null; }
 public System.Collections.BitArray Not() { throw null; }
 public System.Collections.BitArray Or(System.Collections.BitArray value) { throw null; }
 public int PopCount() { throw null; }
 public System.Collections.BitArray RightShift(int count) { throw null; }
 public void Set(int index, bool value) { }
 public void SetAll(bool value) { }
 public System.Collections.BitArray Xor(System.Collections.BitArray value) { throw null; }
 }
}
namespace System.Collections.Generic
{
 public static partial class CollectionExtensions
 {
 public static void AddRange<T>(this System.Collections.Generic.List<T> list, params System.ReadOnlySpan<T> source) { }
 public static void CopyTo<T>(this System.Collections.Generic.List<T> list, System.Span<T> destination) { }
 public static TValue? GetValueOrDefault<TKey, TValue>(this System.Collections.Generic.IReadOnlyDictionary<TKey, TValue> dictionary, TKey key) { throw null; }
 public static TValue GetValueOrDefault<TKey, TValue>(this System.Collections.Generic.IReadOnlyDictionary<TKey, TValue> dictionary, TKey key, TValue defaultValue) { throw null; }
 public static void InsertRange<T>(this System.Collections.Generic.List<T> list, int index, params System.ReadOnlySpan<T> source) { }
 public static bool Remove<TKey, TValue>(this System.Collections.Generic.IDictionary<TKey, TValue> dictionary, TKey key, [System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute(false)] out TValue value) { throw null; }
 public static bool TryAdd<TKey, TValue>(this System.Collections.Generic.IDictionary<TKey, TValue> dictionary, TKey key, TValue value) { throw null; }
 public static System.Collections.ObjectModel.ReadOnlyCollection<T> AsReadOnly<T>(this IList<T> list) { throw null; }
 public static System.Collections.ObjectModel.ReadOnlySet<T> AsReadOnly<T>(this ISet<T> set) { throw null; }
 public static System.Collections.ObjectModel.ReadOnlyDictionary<TKey, TValue> AsReadOnly<TKey, TValue>(this IDictionary<TKey, TValue> dictionary) where TKey : notnull { throw null; }
 }
 public abstract partial class Comparer<T> : System.Collections.Generic.IComparer<T>, System.Collections.IComparer
 {
 protected Comparer() { }
 public static System.Collections.Generic.Comparer<T> Default { get { throw null; } }
 public abstract int Compare(T? x, T? y);
 public static System.Collections.Generic.Comparer<T> Create(System.Comparison<T> comparison) { throw null; }
 int System.Collections.IComparer.Compare(object? x, object? y) { throw null; }
 }
 public partial class Dictionary<TKey, TValue> : System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey, TValue>>, System.Collections.Generic.IDictionary<TKey, TValue>, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>, System.Collections.Generic.IReadOnlyCollection<System.Collections.Generic.KeyValuePair<TKey, TValue>>, System.Collections.Generic.IReadOnlyDictionary<TKey, TValue>, System.Collections.ICollection, System.Collections.IDictionary, System.Collections.IEnumerable, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable where TKey : notnull
 {
 public Dictionary() { }
 public Dictionary(System.Collections.Generic.IDictionary<TKey, TValue> dictionary) { }
 public Dictionary(System.Collections.Generic.IDictionary<TKey, TValue> dictionary, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
 public Dictionary(System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>> collection) { }
 public Dictionary(System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>> collection, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
 public Dictionary(System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
 public Dictionary(int capacity) { }
 public Dictionary(int capacity, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { }
 [System.ObsoleteAttribute("This API supports obsolete formatter-based serialization. It should not be called or extended by application code.", DiagnosticId = "SYSLIB0051", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
 [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
 protected Dictionary(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
 public System.Collections.Generic.IEqualityComparer<TKey> Comparer { get { throw null; } }
 public int Count { get { throw null; } }
 public int Capacity { get { throw null; } }
 public TValue this[TKey key] { get { throw null; } set { } }
 public System.Collections.Generic.Dictionary<TKey, TValue>.KeyCollection Keys { get { throw null; } }
 bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey, TValue>>.IsReadOnly { get { throw null; } }
 System.Collections.Generic.ICollection<TKey> System.Collections.Generic.IDictionary<TKey, TValue>.Keys { get { throw null; } }
 System.Collections.Generic.ICollection<TValue> System.Collections.Generic.IDictionary<TKey, TValue>.Values { get { throw null; } }
 System.Collections.Generic.IEnumerable<TKey> System.Collections.Generic.IReadOnlyDictionary<TKey, TValue>.Keys { get { throw null; } }
 System.Collections.Generic.IEnumerable<TValue> System.Collections.Generic.IReadOnlyDictionary<TKey, TValue>.Values { get { throw null; } }
 bool System.Collections.ICollection.IsSynchronized { get { throw null; } }
 object System.Collections.ICollection.SyncRoot { get { throw null; } }
 bool System.Collections.IDictionary.IsFixedSize { get { throw null; } }
 bool System.Collections.IDictionary.IsReadOnly { get { throw null; } }
 object? System.Collections.IDictionary.this[object key] { get { throw null; } set { } }
 System.Collections.ICollection System.Collections.IDictionary.Keys { get { throw null; } }
 System.Collections.ICollection System.Collections.IDictionary.Values { get { throw null; } }
 public System.Collections.Generic.Dictionary<TKey, TValue>.ValueCollection Values { get { throw null; } }
 public void Add(TKey key, TValue value) { }
 public void Clear() { }
 public bool ContainsKey(TKey key) { throw null; }
 public bool ContainsValue(TValue value) { throw null; }
 public int EnsureCapacity(int capacity) { throw null; }
 public System.Collections.Generic.Dictionary<TKey, TValue>.AlternateLookup<TAlternateKey> GetAlternateLookup<TAlternateKey>() where TAlternateKey : notnull, allows ref struct { throw null; }
 public System.Collections.Generic.Dictionary<TKey, TValue>.Enumerator GetEnumerator() { throw null; }
 [System.ObsoleteAttribute("This API supports obsolete formatter-based serialization. It should not be called or extended by application code.", DiagnosticId = "SYSLIB0051", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
 [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
 public virtual void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
 public virtual void OnDeserialization(object? sender) { }
 public bool Remove(TKey key) { throw null; }
 public bool Remove(TKey key, [System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute(false)] out TValue value) { throw null; }
 void System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey, TValue>>.Add(System.Collections.Generic.KeyValuePair<TKey, TValue> keyValuePair) { }
 bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey, TValue>>.Contains(System.Collections.Generic.KeyValuePair<TKey, TValue> keyValuePair) { throw null; }
 void System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey, TValue>>.CopyTo(System.Collections.Generic.KeyValuePair<TKey, TValue>[] array, int index) { }
 bool System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey, TValue>>.Remove(System.Collections.Generic.KeyValuePair<TKey, TValue> keyValuePair) { throw null; }
 System.Collections.Generic.IEnumerator<System.Collections.Generic.KeyValuePair<TKey, TValue>> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>.GetEnumerator() { throw null; }
 void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
 void System.Collections.IDictionary.Add(object key, object? value) { }
 bool System.Collections.IDictionary.Contains(object key) { throw null; }
 System.Collections.IDictionaryEnumerator System.Collections.IDictionary.GetEnumerator() { throw null; }
 void System.Collections.IDictionary.Remove(object key) { }
 System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; }
 public void TrimExcess() { }
 public void TrimExcess(int capacity) { }
 public bool TryAdd(TKey key, TValue value) { throw null; }
 public bool TryGetAlternateLookup<TAlternateKey>(out System.Collections.Generic.Dictionary<TKey, TValue>.AlternateLookup<TAlternateKey> lookup) where TAlternateKey : notnull, allows ref struct { throw null; }
 public bool TryGetValue(TKey key, [System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute(false)] out TValue value) { throw null; }
 public readonly partial struct AlternateLookup<TAlternateKey> where TAlternateKey : notnull, allows ref struct
 {
 public System.Collections.Generic.Dictionary<TKey, TValue> Dictionary { get { throw null; } }
 public TValue this[TAlternateKey key] { get { throw null; } set { } }
 public bool ContainsKey(TAlternateKey key) { throw null; }
 public bool TryAdd(TAlternateKey key, TValue value) { throw null; }
 public bool TryGetValue(TAlternateKey key, [System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute(false)] out TValue value) { throw null; }
 public bool TryGetValue(TAlternateKey key, [System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute(false)] out TKey actualKey, [System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute(false)] out TValue value) { throw null; }
 public bool Remove(TAlternateKey key) { throw null; }
 public bool Remove(TAlternateKey key, [System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute(false)] out TKey actualKey, [System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute(false)] out TValue value) { throw null; }
 }
 public partial struct Enumerator : System.Collections.Generic.IEnumerator<System.Collections.Generic.KeyValuePair<TKey, TValue>>, System.Collections.IDictionaryEnumerator, System.Collections.IEnumerator, System.IDisposable
 {
 private object _dummy;
 private int _dummyPrimitive;
 public System.Collections.Generic.KeyValuePair<TKey, TValue> Current { get { throw null; } }
 System.Collections.DictionaryEntry System.Collections.IDictionaryEnumerator.Entry { get { throw null; } }
 object System.Collections.IDictionaryEnumerator.Key { get { throw null; } }
 object? System.Collections.IDictionaryEnumerator.Value { get { throw null; } }
 object? System.Collections.IEnumerator.Current { get { throw null; } }
 public void Dispose() { }
 public bool MoveNext() { throw null; }
 void System.Collections.IEnumerator.Reset() { }
 }
 public sealed partial class KeyCollection : System.Collections.Generic.ICollection<TKey>, System.Collections.Generic.IEnumerable<TKey>, System.Collections.Generic.IReadOnlyCollection<TKey>, System.Collections.ICollection, System.Collections.IEnumerable
 {
 public KeyCollection(System.Collections.Generic.Dictionary<TKey, TValue> dictionary) { }
 public int Count { get { throw null; } }
 bool System.Collections.Generic.ICollection<TKey>.IsReadOnly { get { throw null; } }
 bool System.Collections.ICollection.IsSynchronized { get { throw null; } }
 object System.Collections.ICollection.SyncRoot { get { throw null; } }
 public void CopyTo(TKey[] array, int index) { }
 public System.Collections.Generic.Dictionary<TKey, TValue>.KeyCollection.Enumerator GetEnumerator() { throw null; }
 void System.Collections.Generic.ICollection<TKey>.Add(TKey item) { }
 void System.Collections.Generic.ICollection<TKey>.Clear() { }
 public bool Contains(TKey item) { throw null; }
 bool System.Collections.Generic.ICollection<TKey>.Remove(TKey item) { throw null; }
 System.Collections.Generic.IEnumerator<TKey> System.Collections.Generic.IEnumerable<TKey>.GetEnumerator() { throw null; }
 void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
 System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; }
 public partial struct Enumerator : System.Collections.Generic.IEnumerator<TKey>, System.Collections.IEnumerator, System.IDisposable
 {
 private TKey _currentKey;
 private object _dummy;
 private int _dummyPrimitive;
 public TKey Current { get { throw null; } }
 object? System.Collections.IEnumerator.Current { get { throw null; } }
 public void Dispose() { }
 public bool MoveNext() { throw null; }
 void System.Collections.IEnumerator.Reset() { }
 }
 }
 public sealed partial class ValueCollection : System.Collections.Generic.ICollection<TValue>, System.Collections.Generic.IEnumerable<TValue>, System.Collections.Generic.IReadOnlyCollection<TValue>, System.Collections.ICollection, System.Collections.IEnumerable
 {
 public ValueCollection(System.Collections.Generic.Dictionary<TKey, TValue> dictionary) { }
 public int Count { get { throw null; } }
 bool System.Collections.Generic.ICollection<TValue>.IsReadOnly { get { throw null; } }
 bool System.Collections.ICollection.IsSynchronized { get { throw null; } }
 object System.Collections.ICollection.SyncRoot { get { throw null; } }
 public void CopyTo(TValue[] array, int index) { }
 public System.Collections.Generic.Dictionary<TKey, TValue>.ValueCollection.Enumerator GetEnumerator() { throw null; }
 void System.Collections.Generic.ICollection<TValue>.Add(TValue item) { }
 void System.Collections.Generic.ICollection<TValue>.Clear() { }
 bool System.Collections.Generic.ICollection<TValue>.Contains(TValue item) { throw null; }
 bool System.Collections.Generic.ICollection<TValue>.Remove(TValue item) { throw null; }
 System.Collections.Generic.IEnumerator<TValue> System.Collections.Generic.IEnumerable<TValue>.GetEnumerator() { throw null; }
 void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
 System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; }
 public partial struct Enumerator : System.Collections.Generic.IEnumerator<TValue>, System.Collections.IEnumerator, System.IDisposable
 {
 private TValue _currentValue;
 private object _dummy;
 private int _dummyPrimitive;
 public TValue Current { get { throw null; } }
 object? System.Collections.IEnumerator.Current { get { throw null; } }
 public void Dispose() { }
 public bool MoveNext() { throw null; }
 void System.Collections.IEnumerator.Reset() { }
 }
 }
 }
 public abstract partial class EqualityComparer<T> : System.Collections.Generic.IEqualityComparer<T>, System.Collections.IEqualityComparer
 {
 protected EqualityComparer() { }
 public static System.Collections.Generic.EqualityComparer<T> Create(System.Func<T?, T?, bool> equals, System.Func<T, int>? getHashCode = null) { throw null; }
 public static System.Collections.Generic.EqualityComparer<T> Create<TKey>(System.Func<T?, TKey?> keySelector, System.Collections.Generic.IEqualityComparer<TKey>? keyComparer = null) { throw null; }
 public static System.Collections.Generic.EqualityComparer<T> Default { get { throw null; } }
 public abstract bool Equals(T? x, T? y);
 public abstract int GetHashCode([System.Diagnostics.CodeAnalysis.DisallowNullAttribute] T obj);
 bool System.Collections.IEqualityComparer.Equals(object? x, object? y) { throw null; }
 int System.Collections.IEqualityComparer.GetHashCode(object obj) { throw null; }
 }
 public partial class HashSet<T> : System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyCollection<T>, System.Collections.Generic.ISet<T>, System.Collections.Generic.IReadOnlySet<T>, System.Collections.IEnumerable, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable
 {
 public HashSet() { }
 public HashSet(System.Collections.Generic.IEnumerable<T> collection) { }
 public HashSet(System.Collections.Generic.IEnumerable<T> collection, System.Collections.Generic.IEqualityComparer<T>? comparer) { }
 public HashSet(System.Collections.Generic.IEqualityComparer<T>? comparer) { }
 public HashSet(int capacity) { }
 public HashSet(int capacity, System.Collections.Generic.IEqualityComparer<T>? comparer) { }
 [System.ObsoleteAttribute("This API supports obsolete formatter-based serialization. It should not be called or extended by application code.", DiagnosticId = "SYSLIB0051", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
 [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
 protected HashSet(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
 public System.Collections.Generic.IEqualityComparer<T> Comparer { get { throw null; } }
 public int Count { get { throw null; } }
 public int Capacity { get { throw null; } }
 bool System.Collections.Generic.ICollection<T>.IsReadOnly { get { throw null; } }
 public bool Add(T item) { throw null; }
 public void Clear() { }
 public bool Contains(T item) { throw null; }
 public void CopyTo(T[] array) { }
 public void CopyTo(T[] array, int arrayIndex) { }
 public void CopyTo(T[] array, int arrayIndex, int count) { }
 public static System.Collections.Generic.IEqualityComparer<System.Collections.Generic.HashSet<T>> CreateSetComparer() { throw null; }
 public int EnsureCapacity(int capacity) { throw null; }
 public void ExceptWith(System.Collections.Generic.IEnumerable<T> other) { }
 public System.Collections.Generic.HashSet<T>.AlternateLookup<TAlternate> GetAlternateLookup<TAlternate>() where TAlternate : allows ref struct { throw null; }
 public System.Collections.Generic.HashSet<T>.Enumerator GetEnumerator() { throw null; }
 [System.ObsoleteAttribute("This API supports obsolete formatter-based serialization. It should not be called or extended by application code.", DiagnosticId = "SYSLIB0051", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
 [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
 public virtual void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
 public void IntersectWith(System.Collections.Generic.IEnumerable<T> other) { }
 public bool IsProperSubsetOf(System.Collections.Generic.IEnumerable<T> other) { throw null; }
 public bool IsProperSupersetOf(System.Collections.Generic.IEnumerable<T> other) { throw null; }
 public bool IsSubsetOf(System.Collections.Generic.IEnumerable<T> other) { throw null; }
 public bool IsSupersetOf(System.Collections.Generic.IEnumerable<T> other) { throw null; }
 public virtual void OnDeserialization(object? sender) { }
 public bool Overlaps(System.Collections.Generic.IEnumerable<T> other) { throw null; }
 public bool Remove(T item) { throw null; }
 public int RemoveWhere(System.Predicate<T> match) { throw null; }
 public bool SetEquals(System.Collections.Generic.IEnumerable<T> other) { throw null; }
 public void SymmetricExceptWith(System.Collections.Generic.IEnumerable<T> other) { }
 void System.Collections.Generic.ICollection<T>.Add(T item) { }
 System.Collections.Generic.IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator() { throw null; }
 System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; }
 public void TrimExcess() { }
 public void TrimExcess(int capacity) { }
 public bool TryGetAlternateLookup<TAlternate>(out System.Collections.Generic.HashSet<T>.AlternateLookup<TAlternate> lookup) where TAlternate : allows ref struct { throw null; }
 public bool TryGetValue(T equalValue, [System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute(false)] out T actualValue) { throw null; }
 public void UnionWith(System.Collections.Generic.IEnumerable<T> other) { }
 public readonly partial struct AlternateLookup<TAlternate> where TAlternate : allows ref struct
 {
 public System.Collections.Generic.HashSet<T> Set { get { throw null; } }
 public bool Add(TAlternate item) { throw null; }
 public bool Contains(TAlternate item) { throw null; }
 public bool Remove(TAlternate item) { throw null; }
 public bool TryGetValue(TAlternate equalValue, [System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute(false)] out T actualValue) { throw null; }
 }
 public partial struct Enumerator : System.Collections.Generic.IEnumerator<T>, System.Collections.IEnumerator, System.IDisposable
 {
 private T _current;
 private object _dummy;
 private int _dummyPrimitive;
 public T Current { get { throw null; } }
 object? System.Collections.IEnumerator.Current { get { throw null; } }
 public void Dispose() { }
 public bool MoveNext() { throw null; }
 void System.Collections.IEnumerator.Reset() { }
 }
 }
 public partial class List<T> : System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IList<T>, System.Collections.Generic.IReadOnlyCollection<T>, System.Collections.Generic.IReadOnlyList<T>, System.Collections.ICollection, System.Collections.IEnumerable, System.Collections.IList
 {
 public List() { }
 public List(System.Collections.Generic.IEnumerable<T> collection) { }
 public List(int capacity) { }
 public int Capacity { get { throw null; } set { } }
 public int Count { get { throw null; } }
 public T this[int index] { get { throw null; } set { } }
 bool System.Collections.Generic.ICollection<T>.IsReadOnly { get { throw null; } }
 bool System.Collections.ICollection.IsSynchronized { get { throw null; } }
 object System.Collections.ICollection.SyncRoot { get { throw null; } }
 bool System.Collections.IList.IsFixedSize { get { throw null; } }
 bool System.Collections.IList.IsReadOnly { get { throw null; } }
 object? System.Collections.IList.this[int index] { get { throw null; } set { } }
 public void Add(T item) { }
 public void AddRange(System.Collections.Generic.IEnumerable<T> collection) { }
 public System.Collections.ObjectModel.ReadOnlyCollection<T> AsReadOnly() { throw null; }
 public int BinarySearch(int index, int count, T item, System.Collections.Generic.IComparer<T>? comparer) { throw null; }
 public int BinarySearch(T item) { throw null; }
 public int BinarySearch(T item, System.Collections.Generic.IComparer<T>? comparer) { throw null; }
 public void Clear() { }
 public bool Contains(T item) { throw null; }
 public System.Collections.Generic.List<TOutput> ConvertAll<TOutput>(System.Converter<T, TOutput> converter) { throw null; }
 public void CopyTo(int index, T[] array, int arrayIndex, int count) { }
 public void CopyTo(T[] array) { }
 public void CopyTo(T[] array, int arrayIndex) { }
 public int EnsureCapacity(int capacity) { throw null; }
 public bool Exists(System.Predicate<T> match) { throw null; }
 public T? Find(System.Predicate<T> match) { throw null; }
 public System.Collections.Generic.List<T> FindAll(System.Predicate<T> match) { throw null; }
 public int FindIndex(int startIndex, int count, System.Predicate<T> match) { throw null; }
 public int FindIndex(int startIndex, System.Predicate<T> match) { throw null; }
 public int FindIndex(System.Predicate<T> match) { throw null; }
 public T? FindLast(System.Predicate<T> match) { throw null; }
 public int FindLastIndex(int startIndex, int count, System.Predicate<T> match) { throw null; }
 public int FindLastIndex(int startIndex, System.Predicate<T> match) { throw null; }
 public int FindLastIndex(System.Predicate<T> match) { throw null; }
 public void ForEach(System.Action<T> action) { }
 public System.Collections.Generic.List<T>.Enumerator GetEnumerator() { throw null; }
 public System.Collections.Generic.List<T> GetRange(int index, int count) { throw null; }
 public int IndexOf(T item) { throw null; }
 public int IndexOf(T item, int index) { throw null; }
 public int IndexOf(T item, int index, int count) { throw null; }
 public void Insert(int index, T item) { }
 public void InsertRange(int index, System.Collections.Generic.IEnumerable<T> collection) { }
 public int LastIndexOf(T item) { throw null; }
 public int LastIndexOf(T item, int index) { throw null; }
 public int LastIndexOf(T item, int index, int count) { throw null; }
 public bool Remove(T item) { throw null; }
 public int RemoveAll(System.Predicate<T> match) { throw null; }
 public void RemoveAt(int index) { }
 public void RemoveRange(int index, int count) { }
 public void Reverse() { }
 public void Reverse(int index, int count) { }
 public System.Collections.Generic.List<T> Slice(int start, int length) { throw null; }
 public void Sort() { }
 public void Sort(System.Collections.Generic.IComparer<T>? comparer) { }
 public void Sort(System.Comparison<T> comparison) { }
 public void Sort(int index, int count, System.Collections.Generic.IComparer<T>? comparer) { }
 System.Collections.Generic.IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator() { throw null; }
 void System.Collections.ICollection.CopyTo(System.Array array, int arrayIndex) { }
 System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; }
 int System.Collections.IList.Add(object? item) { throw null; }
 bool System.Collections.IList.Contains(object? item) { throw null; }
 int System.Collections.IList.IndexOf(object? item) { throw null; }
 void System.Collections.IList.Insert(int index, object? item) { }
 void System.Collections.IList.Remove(object? item) { }
 public T[] ToArray() { throw null; }
 public void TrimExcess() { }
 public bool TrueForAll(System.Predicate<T> match) { throw null; }
 public partial struct Enumerator : System.Collections.Generic.IEnumerator<T>, System.Collections.IEnumerator, System.IDisposable
 {
 private T _current;
 private object _dummy;
 private int _dummyPrimitive;
 public T Current { get { throw null; } }
 object? System.Collections.IEnumerator.Current { get { throw null; } }
 public void Dispose() { }
 public bool MoveNext() { throw null; }
 void System.Collections.IEnumerator.Reset() { }
 }
 }
 public partial class Queue<T> : System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyCollection<T>, System.Collections.ICollection, System.Collections.IEnumerable
 {
 public Queue() { }
 public Queue(System.Collections.Generic.IEnumerable<T> collection) { }
 public Queue(int capacity) { }
 public int Count { get { throw null; } }
 public int Capacity { get { throw null; } }
 bool System.Collections.ICollection.IsSynchronized { get { throw null; } }
 object System.Collections.ICollection.SyncRoot { get { throw null; } }
 public void Clear() { }
 public bool Contains(T item) { throw null; }
 public void CopyTo(T[] array, int arrayIndex) { }
 public T Dequeue() { throw null; }
 public void Enqueue(T item) { }
 public System.Collections.Generic.Queue<T>.Enumerator GetEnumerator() { throw null; }
 public T Peek() { throw null; }
 System.Collections.Generic.IEnumerator<T> System.Collections.Generic.IEnumerable<T>.GetEnumerator() { throw null; }
 void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
 System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; }
 public T[] ToArray() { throw null; }
 public void TrimExcess() { }
 public void TrimExcess(int capacity) { }
 public int EnsureCapacity(int capacity) { throw null; }
 public bool TryDequeue([System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute(false)] out T result) { throw null; }
 public bool TryPeek([System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute(false)] out T result) { throw null; }
 public partial struct Enumerator : System.Collections.Generic.IEnumerator<T>, System.Collections.IEnumerator, System.IDisposable
 {
 private T _currentElement;
 private object _dummy;
 private int _dummyPrimitive;
 public T Current { get { throw null; } }
 object? System.Collections.IEnumerator.Current { get { throw null; } }
 public void Dispose() { }
 public bool MoveNext() { throw null; }
 void System.Collections.IEnumerator.Reset() { }
 }
 }
 public sealed class ReferenceEqualityComparer : System.Collections.Generic.IEqualityComparer<object?>, System.Collections.IEqualityComparer
 {
 private ReferenceEqualityComparer() { }
 public static System.Collections.Generic.ReferenceEqualityComparer Instance { get { throw null; } }
 public new bool Equals(object? x, object? y) { throw null; }
 public int GetHashCode(object? obj) { throw null; }
 }
}