# encoding: utf-8
# module System.Collections.Generic calls itself Generic
# from mscorlib,Version=4.0.0.0,Culture=neutral,PublicKeyToken=b77a5c561934e089,System,Version=4.0.0.0,Culture=neutral,PublicKeyToken=b77a5c561934e089
# by generator 1.145
""" NamespaceTracker represent a CLS namespace. """
# no imports

# no functions
# classes

class Comparer(object,IComparer,IComparer[T]):
 # no doc
 def Compare(self,x,y):
  """
  Compare(self: Comparer[T],x: T,y: T) -> int

  

   When overridden in a derived class,performs a comparison of two objects of the same type and 

    returns a value indicating whether one object is less than,equal to,or greater than the other.

  

  

   x: The first object to compare.

   y: The second object to compare.

   Returns: A signed integer that indicates the relative values of x and y,as shown in the following 

    table.Value Meaning Less than zero x is less than y.Zero x equals y.Greater than zero x is 

    greater than y.
  """
  pass
 @staticmethod
 def Create(comparison):
  """ Create(comparison: Comparison[T]) -> Comparer[T] """
  pass
 def __cmp__(self,*args):
  """ x.__cmp__(y) <==> cmp(x,y) """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __reduce_ex__(self,*args):
  pass
 def __repr__(self,*args):
  """ __repr__(self: object) -> str """
  pass

class Dictionary(object,IDictionary[TKey,TValue],ICollection[KeyValuePair[TKey,TValue]],IEnumerable[KeyValuePair[TKey,TValue]],IEnumerable,IDictionary,ICollection,IReadOnlyDictionary[TKey,TValue],IReadOnlyCollection[KeyValuePair[TKey,TValue]],ISerializable,IDeserializationCallback):
 """
 Dictionary[TKey,TValue]()

 Dictionary[TKey,TValue](capacity: int)

 Dictionary[TKey,TValue](comparer: IEqualityComparer[TKey])

 Dictionary[TKey,TValue](capacity: int,comparer: IEqualityComparer[TKey])

 Dictionary[TKey,TValue](dictionary: IDictionary[TKey,TValue])

 Dictionary[TKey,TValue](dictionary: IDictionary[TKey,TValue],comparer: IEqualityComparer[TKey])
 """
 def Add(self,key,value):
  """
  Add(self: Dictionary[TKey,TValue],key: TKey,value: TValue)

   Adds the specified key and value to the dictionary.

  

   key: The key of the element to add.

   value: The value of the element to add. The value can be null for reference types.
  """
  pass
 def Clear(self):
  """
  Clear(self: Dictionary[TKey,TValue])

   Removes all keys and values from the System.Collections.Generic.Dictionary.
  """
  pass
 def ContainsKey(self,key):
  """
  ContainsKey(self: Dictionary[TKey,TValue],key: TKey) -> bool

  

   Determines whether the System.Collections.Generic.Dictionary contains the specified key.

  

   key: The key to locate in the System.Collections.Generic.Dictionary.

   Returns: true if the System.Collections.Generic.Dictionary contains an element with the specified key; 

    otherwise,false.
  """
  pass
 def ContainsValue(self,value):
  """
  ContainsValue(self: Dictionary[TKey,TValue],value: TValue) -> bool

  

   Determines whether the System.Collections.Generic.Dictionary contains a specific value.

  

   value: The value to locate in the System.Collections.Generic.Dictionary. The value can be null for 

    reference types.

  

   Returns: true if the System.Collections.Generic.Dictionary contains an element with the specified value; 

    otherwise,false.
  """
  pass
 def GetEnumerator(self):
  """
  GetEnumerator(self: Dictionary[TKey,TValue]) -> Enumerator

  

   Returns an enumerator that iterates through the System.Collections.Generic.Dictionary.

   Returns: A System.Collections.Generic.Dictionary structure for the System.Collections.Generic.Dictionary.
  """
  pass
 def GetObjectData(self,info,context):
  """
  GetObjectData(self: Dictionary[TKey,TValue],info: SerializationInfo,context: StreamingContext)

   Implements the System.Runtime.Serialization.ISerializable interface and returns the data needed 

    to serialize the System.Collections.Generic.Dictionary instance.

  

  

   info: A System.Runtime.Serialization.SerializationInfo object that contains the information required 

    to serialize the System.Collections.Generic.Dictionary instance.

  

   context: A System.Runtime.Serialization.StreamingContext structure that contains the source and 

    destination of the serialized stream associated with the System.Collections.Generic.Dictionary 

    instance.
  """
  pass
 def OnDeserialization(self,sender):
  """
  OnDeserialization(self: Dictionary[TKey,TValue],sender: object)

   Implements the System.Runtime.Serialization.ISerializable interface and raises the 

    deserialization event when the deserialization is complete.

  

  

   sender: The source of the deserialization event.
  """
  pass
 def Remove(self,key):
  """
  Remove(self: Dictionary[TKey,TValue],key: TKey) -> bool

  

   Removes the value with the specified key from the System.Collections.Generic.Dictionary.

  

   key: The key of the element to remove.

   Returns: true if the element is successfully found and removed; otherwise,false.  This method returns 

    false if key is not found in the System.Collections.Generic.Dictionary.
  """
  pass
 def TryGetValue(self,key,value):
  """ TryGetValue(self: Dictionary[TKey,TValue],key: TKey) -> (bool,TValue) """
  pass
 def __add__(self,*args):
  """ x.__add__(y) <==> x+y """
  pass
 def __contains__(self,*args):
  """
  __contains__(self: IDictionary[TKey,TValue],key: TKey) -> bool

  

   Determines whether the System.Collections.Generic.IDictionary contains an element with the 

    specified key.

  

  

   key: The key to locate in the System.Collections.Generic.IDictionary.

   Returns: true if the System.Collections.Generic.IDictionary contains an element with the key; otherwise,

    false.

  

  __contains__(self: IDictionary,key: object) -> bool

  

   Determines whether the System.Collections.IDictionary object contains an element with the 

    specified key.

  

  

   key: The key to locate in the System.Collections.IDictionary object.

   Returns: true if the System.Collections.IDictionary contains an element with the key; otherwise,false.
  """
  pass
 def __getitem__(self,*args):
  """ x.__getitem__(y) <==> x[y] """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __iter__(self,*args):
  """ __iter__(self: IEnumerable) -> object """
  pass
 def __len__(self,*args):
  """ x.__len__() <==> len(x) """
  pass
 @staticmethod
 def __new__(self,*__args):
  """
  __new__(cls: type)

  __new__(cls: type,capacity: int)

  __new__(cls: type,comparer: IEqualityComparer[TKey])

  __new__(cls: type,capacity: int,comparer: IEqualityComparer[TKey])

  __new__(cls: type,dictionary: IDictionary[TKey,TValue])

  __new__(cls: type,dictionary: IDictionary[TKey,TValue],comparer: IEqualityComparer[TKey])

  __new__(cls: type,info: SerializationInfo,context: StreamingContext)
  """
  pass
 def __reduce_ex__(self,*args):
  pass
 def __repr__(self,*args):
  """
  __repr__(self: Dictionary[TKey,TValue]) -> str

  __repr__(self: Dictionary[K,V]) -> str
  """
  pass
 def __setitem__(self,*args):
  """ x.__setitem__(i,y) <==> x[i]= """
  pass
 Comparer=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets the System.Collections.Generic.IEqualityComparer that is used to determine equality of keys for the dictionary.



Get: Comparer(self: Dictionary[TKey,TValue]) -> IEqualityComparer[TKey]



"""

 Count=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets the number of key/value pairs contained in the System.Collections.Generic.Dictionary.



Get: Count(self: Dictionary[TKey,TValue]) -> int



"""

 Keys=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets a collection containing the keys in the System.Collections.Generic.Dictionary.



Get: Keys(self: Dictionary[TKey,TValue]) -> KeyCollection



"""

 Values=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets a collection containing the values in the System.Collections.Generic.Dictionary.



Get: Values(self: Dictionary[TKey,TValue]) -> ValueCollection



"""


 Enumerator=None
 KeyCollection=None
 ValueCollection=None


class EqualityComparer(object,IEqualityComparer,IEqualityComparer[T]):
 # no doc
 def Equals(self,*__args):
  """
  Equals(self: EqualityComparer[T],x: T,y: T) -> bool

  

   When overridden in a derived class,determines whether two objects of type T are equal.

  

   x: The first object to compare.

   y: The second object to compare.

   Returns: true if the specified objects are equal; otherwise,false.
  """
  pass
 def GetHashCode(self,obj=None):
  """
  GetHashCode(self: EqualityComparer[T],obj: T) -> int

  

   When overridden in a derived class,serves as a hash function for the specified object for 

    hashing algorithms and data structures,such as a hash table.

  

  

   obj: The object for which to get a hash code.

   Returns: A hash code for the specified object.
  """
  pass
 def __eq__(self,*args):
  """ x.__eq__(y) <==> x==y """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __reduce_ex__(self,*args):
  pass
 def __repr__(self,*args):
  """ __repr__(self: object) -> str """
  pass

class ICollection(IEnumerable[T],IEnumerable):
 # no doc
 def Add(self,item):
  """
  Add(self: ICollection[T],item: T)

   Adds an item to the System.Collections.Generic.ICollection.

  

   item: The object to add to the System.Collections.Generic.ICollection.
  """
  pass
 def Clear(self):
  """
  Clear(self: ICollection[T])

   Removes all items from the System.Collections.Generic.ICollection.
  """
  pass
 def Contains(self,item):
  """
  Contains(self: ICollection[T],item: T) -> bool

  

   Determines whether the System.Collections.Generic.ICollection contains a specific value.

  

   item: The object to locate in the System.Collections.Generic.ICollection.

   Returns: true if item is found in the System.Collections.Generic.ICollection; otherwise,false.
  """
  pass
 def CopyTo(self,array,arrayIndex):
  """ CopyTo(self: ICollection[T],array: Array[T],arrayIndex: int) """
  pass
 def Remove(self,item):
  """
  Remove(self: ICollection[T],item: T) -> bool

  

   Removes the first occurrence of a specific object from the 

    System.Collections.Generic.ICollection.

  

  

   item: The object to remove from the System.Collections.Generic.ICollection.

   Returns: true if item was successfully removed from the System.Collections.Generic.ICollection; 

    otherwise,false. This method also returns false if item is not found in the original 

    System.Collections.Generic.ICollection.
  """
  pass
 def __add__(self,*args):
  """ x.__add__(y) <==> x+y """
  pass
 def __contains__(self,*args):
  """ __contains__[T](enumerable: IEnumerable[T],value: T) -> bool """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __iter__(self,*args):
  """ __iter__(self: IEnumerable) -> object """
  pass
 Count=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets the number of elements contained in the System.Collections.Generic.ICollection.



Get: Count(self: ICollection[T]) -> int



"""

 IsReadOnly=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets a value indicating whether the System.Collections.Generic.ICollection is read-only.



Get: IsReadOnly(self: ICollection[T]) -> bool



"""



class IComparer:
 # no doc
 def Compare(self,x,y):
  """
  Compare(self: IComparer[T],x: T,y: T) -> int

  

   Compares two objects and returns a value indicating whether one is less than,equal to,or 

    greater than the other.

  

  

   x: The first object to compare.

   y: The second object to compare.

   Returns: A signed integer that indicates the relative values of x and y,as shown in the following 

    table.Value Meaning Less than zerox is less than y.Zerox equals y.Greater than zerox is greater 

    than y.
  """
  pass
 def __cmp__(self,*args):
  """ x.__cmp__(y) <==> cmp(x,y) """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass

class IDictionary(ICollection[KeyValuePair[TKey,TValue]],IEnumerable[KeyValuePair[TKey,TValue]],IEnumerable):
 # no doc
 def Add(self,key,value):
  """
  Add(self: IDictionary[TKey,TValue],key: TKey,value: TValue)

   Adds an element with the provided key and value to the System.Collections.Generic.IDictionary.

  

   key: The object to use as the key of the element to add.

   value: The object to use as the value of the element to add.
  """
  pass
 def ContainsKey(self,key):
  """
  ContainsKey(self: IDictionary[TKey,TValue],key: TKey) -> bool

  

   Determines whether the System.Collections.Generic.IDictionary contains an element with the 

    specified key.

  

  

   key: The key to locate in the System.Collections.Generic.IDictionary.

   Returns: true if the System.Collections.Generic.IDictionary contains an element with the key; otherwise,

    false.
  """
  pass
 def Remove(self,key):
  """
  Remove(self: IDictionary[TKey,TValue],key: TKey) -> bool

  

   Removes the element with the specified key from the System.Collections.Generic.IDictionary.

  

   key: The key of the element to remove.

   Returns: true if the element is successfully removed; otherwise,false.  This method also returns false 

    if key was not found in the original System.Collections.Generic.IDictionary.
  """
  pass
 def TryGetValue(self,key,value):
  """ TryGetValue(self: IDictionary[TKey,TValue],key: TKey) -> (bool,TValue) """
  pass
 def __add__(self,*args):
  """ x.__add__(y) <==> x+y """
  pass
 def __contains__(self,*args):
  """ __contains__(self: ICollection[KeyValuePair[TKey,TValue]],item: KeyValuePair[TKey,TValue]) -> bool """
  pass
 def __getitem__(self,*args):
  """ x.__getitem__(y) <==> x[y] """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __iter__(self,*args):
  """ __iter__(self: IEnumerable) -> object """
  pass
 def __len__(self,*args):
  """ x.__len__() <==> len(x) """
  pass
 def __setitem__(self,*args):
  """ x.__setitem__(i,y) <==> x[i]= """
  pass
 Keys=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets an System.Collections.Generic.ICollection containing the keys of the System.Collections.Generic.IDictionary.



Get: Keys(self: IDictionary[TKey,TValue]) -> ICollection[TKey]



"""

 Values=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets an System.Collections.Generic.ICollection containing the values in the System.Collections.Generic.IDictionary.



Get: Values(self: IDictionary[TKey,TValue]) -> ICollection[TValue]



"""



class IEnumerable(IEnumerable):
 # no doc
 def GetEnumerator(self):
  """
  GetEnumerator(self: IEnumerable[T]) -> IEnumerator[T]

  

   Returns an enumerator that iterates through the collection.

   Returns: A System.Collections.Generic.IEnumerator that can be used to iterate through the collection.
  """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass

class IEnumerator(IDisposable,IEnumerator):
 # no doc
 def next(self,*args):
  """ next(self: object) -> object """
  pass
 def __enter__(self,*args):
  """
  __enter__(self: IDisposable) -> object

  

   Provides the implementation of __enter__ for objects which implement IDisposable.
  """
  pass
 def __exit__(self,*args):
  """
  __exit__(self: IDisposable,exc_type: object,exc_value: object,exc_back: object)

   Provides the implementation of __exit__ for objects which implement IDisposable.
  """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __iter__(self,*args):
  """ __iter__[T](self: IEnumerator[T]) -> object """
  pass
 Current=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets the element in the collection at the current position of the enumerator.



Get: Current(self: IEnumerator[T]) -> T



"""



class IEqualityComparer:
 # no doc
 def Equals(self,x,y):
  """
  Equals(self: IEqualityComparer[T],x: T,y: T) -> bool

  

   Determines whether the specified objects are equal.

  

   x: The first object of type T to compare.

   y: The second object of type T to compare.

   Returns: true if the specified objects are equal; otherwise,false.
  """
  pass
 def GetHashCode(self,obj):
  """
  GetHashCode(self: IEqualityComparer[T],obj: T) -> int

  

   Returns a hash code for the specified object.

  

   obj: The System.Object for which a hash code is to be returned.

   Returns: A hash code for the specified object.
  """
  pass
 def __eq__(self,*args):
  """ x.__eq__(y) <==> x==y """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass

class IList(ICollection[T],IEnumerable[T],IEnumerable):
 # no doc
 def IndexOf(self,item):
  """
  IndexOf(self: IList[T],item: T) -> int

  

   Determines the index of a specific item in the System.Collections.Generic.IList.

  

   item: The object to locate in the System.Collections.Generic.IList.

   Returns: The index of item if found in the list; otherwise,-1.
  """
  pass
 def Insert(self,index,item):
  """
  Insert(self: IList[T],index: int,item: T)

   Inserts an item to the System.Collections.Generic.IList at the specified index.

  

   index: The zero-based index at which item should be inserted.

   item: The object to insert into the System.Collections.Generic.IList.
  """
  pass
 def RemoveAt(self,index):
  """
  RemoveAt(self: IList[T],index: int)

   Removes the System.Collections.Generic.IList item at the specified index.

  

   index: The zero-based index of the item to remove.
  """
  pass
 def __contains__(self,*args):
  """
  __contains__(self: ICollection[T],item: T) -> bool

  

   Determines whether the System.Collections.Generic.ICollection contains a specific value.

  

   item: The object to locate in the System.Collections.Generic.ICollection.

   Returns: true if item is found in the System.Collections.Generic.ICollection; otherwise,false.
  """
  pass
 def __getitem__(self,*args):
  """ x.__getitem__(y) <==> x[y] """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __iter__(self,*args):
  """ __iter__(self: IEnumerable) -> object """
  pass
 def __len__(self,*args):
  """ x.__len__() <==> len(x) """
  pass
 def __setitem__(self,*args):
  """ x.__setitem__(i,y) <==> x[i]= """
  pass

class IReadOnlyCollection(IEnumerable[T],IEnumerable):
 # no doc
 def __contains__(self,*args):
  """ __contains__[T](enumerable: IEnumerable[T],value: T) -> bool """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __iter__(self,*args):
  """ __iter__(self: IEnumerable) -> object """
  pass
 Count=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: Count(self: IReadOnlyCollection[T]) -> int



"""



class IReadOnlyDictionary(IReadOnlyCollection[KeyValuePair[TKey,TValue]],IEnumerable[KeyValuePair[TKey,TValue]],IEnumerable):
 # no doc
 def ContainsKey(self,key):
  """ ContainsKey(self: IReadOnlyDictionary[TKey,TValue],key: TKey) -> bool """
  pass
 def TryGetValue(self,key,value):
  """ TryGetValue(self: IReadOnlyDictionary[TKey,TValue],key: TKey) -> (bool,TValue) """
  pass
 def __contains__(self,*args):
  """ __contains__[KeyValuePair`2](enumerable: IEnumerable[KeyValuePair[TKey,TValue]],value: KeyValuePair[TKey,TValue]) -> bool """
  pass
 def __getitem__(self,*args):
  """ x.__getitem__(y) <==> x[y] """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __iter__(self,*args):
  """ __iter__(self: IEnumerable) -> object """
  pass
 Keys=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: Keys(self: IReadOnlyDictionary[TKey,TValue]) -> IEnumerable[TKey]



"""

 Values=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Get: Values(self: IReadOnlyDictionary[TKey,TValue]) -> IEnumerable[TValue]



"""



class IReadOnlyList(IReadOnlyCollection[T],IEnumerable[T],IEnumerable):
 # no doc
 def __contains__(self,*args):
  """ __contains__[T](enumerable: IEnumerable[T],value: T) -> bool """
  pass
 def __getitem__(self,*args):
  """ x.__getitem__(y) <==> x[y] """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __iter__(self,*args):
  """ __iter__(self: IEnumerable) -> object """
  pass

class ISet(ICollection[T],IEnumerable[T],IEnumerable):
 # no doc
 def Add(self,item):
  """
  Add(self: ISet[T],item: T) -> bool

  

   Adds an element to the current set and returns a value to indicate if the element was 

    successfully added.

  

  

   item: The element to add to the set.

   Returns: true if the element is added to the set; false if the element is already in the set.
  """
  pass
 def ExceptWith(self,other):
  """
  ExceptWith(self: ISet[T],other: IEnumerable[T])

   Removes all elements in the specified collection from the current set.

  

   other: The collection of items to remove from the set.
  """
  pass
 def IntersectWith(self,other):
  """
  IntersectWith(self: ISet[T],other: IEnumerable[T])

   Modifies the current set so that it contains only elements that are also in a specified 

    collection.

  

  

   other: The collection to compare to the current set.
  """
  pass
 def IsProperSubsetOf(self,other):
  """
  IsProperSubsetOf(self: ISet[T],other: IEnumerable[T]) -> bool

  

   Determines whether the current set is a proper (strict) subset of a specified collection.

  

   other: The collection to compare to the current set.

   Returns: true if the current set is a proper subset of other; otherwise,false.
  """
  pass
 def IsProperSupersetOf(self,other):
  """
  IsProperSupersetOf(self: ISet[T],other: IEnumerable[T]) -> bool

  

   Determines whether the current set is a proper (strict) superset of a specified collection.

  

   other: The collection to compare to the current set.

   Returns: true if the current set is a proper superset of other; otherwise,false.
  """
  pass
 def IsSubsetOf(self,other):
  """
  IsSubsetOf(self: ISet[T],other: IEnumerable[T]) -> bool

  

   Determines whether a set is a subset of a specified collection.

  

   other: The collection to compare to the current set.

   Returns: true if the current set is a subset of other; otherwise,false.
  """
  pass
 def IsSupersetOf(self,other):
  """
  IsSupersetOf(self: ISet[T],other: IEnumerable[T]) -> bool

  

   Determines whether the current set is a superset of a specified collection.

  

   other: The collection to compare to the current set.

   Returns: true if the current set is a superset of other; otherwise,false.
  """
  pass
 def Overlaps(self,other):
  """
  Overlaps(self: ISet[T],other: IEnumerable[T]) -> bool

  

   Determines whether the current set overlaps with the specified collection.

  

   other: The collection to compare to the current set.

   Returns: true if the current set and other share at least one common element; otherwise,false.
  """
  pass
 def SetEquals(self,other):
  """
  SetEquals(self: ISet[T],other: IEnumerable[T]) -> bool

  

   Determines whether the current set and the specified collection contain the same elements.

  

   other: The collection to compare to the current set.

   Returns: true if the current set is equal to other; otherwise,false.
  """
  pass
 def SymmetricExceptWith(self,other):
  """
  SymmetricExceptWith(self: ISet[T],other: IEnumerable[T])

   Modifies the current set so that it contains only elements that are present either in the 

    current set or in the specified collection,but not both.

  

  

   other: The collection to compare to the current set.
  """
  pass
 def UnionWith(self,other):
  """
  UnionWith(self: ISet[T],other: IEnumerable[T])

   Modifies the current set so that it contains all elements that are present in both the current 

    set and in the specified collection.

  

  

   other: The collection to compare to the current set.
  """
  pass
 def __add__(self,*args):
  """ x.__add__(y) <==> x+y """
  pass
 def __contains__(self,*args):
  """
  __contains__(self: ICollection[T],item: T) -> bool

  

   Determines whether the System.Collections.Generic.ICollection contains a specific value.

  

   item: The object to locate in the System.Collections.Generic.ICollection.

   Returns: true if item is found in the System.Collections.Generic.ICollection; otherwise,false.
  """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __iter__(self,*args):
  """ __iter__(self: IEnumerable) -> object """
  pass
 def __len__(self,*args):
  """ x.__len__() <==> len(x) """
  pass

class KeyNotFoundException(SystemException,ISerializable,_Exception):
 """
 The exception that is thrown when the key specified for accessing an element in a collection does not match any key in the collection.

 

 KeyNotFoundException()

 KeyNotFoundException(message: str)

 KeyNotFoundException(message: str,innerException: Exception)
 """
 def add_SerializeObjectState(self,*args):
  """ add_SerializeObjectState(self: Exception,value: EventHandler[SafeSerializationEventArgs]) """
  pass
 def remove_SerializeObjectState(self,*args):
  """ remove_SerializeObjectState(self: Exception,value: EventHandler[SafeSerializationEventArgs]) """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 @staticmethod
 def __new__(self,message=None,innerException=None):
  """
  __new__(cls: type)

  __new__(cls: type,message: str)

  __new__(cls: type,message: str,innerException: Exception)

  __new__(cls: type,info: SerializationInfo,context: StreamingContext)
  """
  pass
 def __reduce_ex__(self,*args):
  pass
 def __str__(self,*args):
  pass

class KeyValuePair(object):
 """ KeyValuePair[TKey,TValue](key: TKey,value: TValue) """
 def ToString(self):
  """
  ToString(self: KeyValuePair[TKey,TValue]) -> str

  

   Returns a string representation of the System.Collections.Generic.KeyValuePair,using the string 

    representations of the key and value.

  

   Returns: A string representation of the System.Collections.Generic.KeyValuePair,which includes the 

    string representations of the key and value.
  """
  pass
 @staticmethod
 def __new__(self,key,value):
  """
  __new__(cls: type,key: TKey,value: TValue)

  __new__[KeyValuePair`2]() -> KeyValuePair[TKey,TValue]
  """
  pass
 Key=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets the key in the key/value pair.



Get: Key(self: KeyValuePair[TKey,TValue]) -> TKey



"""

 Value=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets the value in the key/value pair.



Get: Value(self: KeyValuePair[TKey,TValue]) -> TValue



"""



class LinkedList(object,ICollection[T],IEnumerable[T],IEnumerable,ICollection,IReadOnlyCollection[T],ISerializable,IDeserializationCallback):
 """
 LinkedList[T]()

 LinkedList[T](collection: IEnumerable[T])
 """
 def AddAfter(self,node,*__args):
  """
  AddAfter(self: LinkedList[T],node: LinkedListNode[T],value: T) -> LinkedListNode[T]

  

   Adds a new node containing the specified value after the specified existing node in the 

    System.Collections.Generic.LinkedList.

  

  

   node: The System.Collections.Generic.LinkedListNode after which to insert a new 

    System.Collections.Generic.LinkedListNode containing value.

  

   value: The value to add to the System.Collections.Generic.LinkedList.

   Returns: The new System.Collections.Generic.LinkedListNode containing value.

  AddAfter(self: LinkedList[T],node: LinkedListNode[T],newNode: LinkedListNode[T])

   Adds the specified new node after the specified existing node in the 

    System.Collections.Generic.LinkedList.

  

  

   node: The System.Collections.Generic.LinkedListNode after which to insert newNode.

   newNode: The new System.Collections.Generic.LinkedListNode to add to the 

    System.Collections.Generic.LinkedList.
  """
  pass
 def AddBefore(self,node,*__args):
  """
  AddBefore(self: LinkedList[T],node: LinkedListNode[T],newNode: LinkedListNode[T])

   Adds the specified new node before the specified existing node in the 

    System.Collections.Generic.LinkedList.

  

  

   node: The System.Collections.Generic.LinkedListNode before which to insert newNode.

   newNode: The new System.Collections.Generic.LinkedListNode to add to the 

    System.Collections.Generic.LinkedList.

  

  AddBefore(self: LinkedList[T],node: LinkedListNode[T],value: T) -> LinkedListNode[T]

  

   Adds a new node containing the specified value before the specified existing node in the 

    System.Collections.Generic.LinkedList.

  

  

   node: The System.Collections.Generic.LinkedListNode before which to insert a new 

    System.Collections.Generic.LinkedListNode containing value.

  

   value: The value to add to the System.Collections.Generic.LinkedList.

   Returns: The new System.Collections.Generic.LinkedListNode containing value.
  """
  pass
 def AddFirst(self,*__args):
  """
  AddFirst(self: LinkedList[T],node: LinkedListNode[T])

   Adds the specified new node at the start of the System.Collections.Generic.LinkedList.

  

   node: The new System.Collections.Generic.LinkedListNode to add at the start of the 

    System.Collections.Generic.LinkedList.

  

  AddFirst(self: LinkedList[T],value: T) -> LinkedListNode[T]

  

   Adds a new node containing the specified value at the start of the 

    System.Collections.Generic.LinkedList.

  

  

   value: The value to add at the start of the System.Collections.Generic.LinkedList.

   Returns: The new System.Collections.Generic.LinkedListNode containing value.
  """
  pass
 def AddLast(self,*__args):
  """
  AddLast(self: LinkedList[T],node: LinkedListNode[T])

   Adds the specified new node at the end of the System.Collections.Generic.LinkedList.

  

   node: The new System.Collections.Generic.LinkedListNode to add at the end of the 

    System.Collections.Generic.LinkedList.

  

  AddLast(self: LinkedList[T],value: T) -> LinkedListNode[T]

  

   Adds a new node containing the specified value at the end of the 

    System.Collections.Generic.LinkedList.

  

  

   value: The value to add at the end of the System.Collections.Generic.LinkedList.

   Returns: The new System.Collections.Generic.LinkedListNode containing value.
  """
  pass
 def Clear(self):
  """
  Clear(self: LinkedList[T])

   Removes all nodes from the System.Collections.Generic.LinkedList.
  """
  pass
 def Contains(self,value):
  """
  Contains(self: LinkedList[T],value: T) -> bool

  

   Determines whether a value is in the System.Collections.Generic.LinkedList.

  

   value: The value to locate in the System.Collections.Generic.LinkedList. The value can be null for 

    reference types.

  

   Returns: true if value is found in the System.Collections.Generic.LinkedList; otherwise,false.
  """
  pass
 def CopyTo(self,array,index):
  """ CopyTo(self: LinkedList[T],array: Array[T],index: int) """
  pass
 def Find(self,value):
  """
  Find(self: LinkedList[T],value: T) -> LinkedListNode[T]

  

   Finds the first node that contains the specified value.

  

   value: The value to locate in the System.Collections.Generic.LinkedList.

   Returns: The first System.Collections.Generic.LinkedListNode that contains the specified value,if found; 

    otherwise,null.
  """
  pass
 def FindLast(self,value):
  """
  FindLast(self: LinkedList[T],value: T) -> LinkedListNode[T]

  

   Finds the last node that contains the specified value.

  

   value: The value to locate in the System.Collections.Generic.LinkedList.

   Returns: The last System.Collections.Generic.LinkedListNode that contains the specified value,if found; 

    otherwise,null.
  """
  pass
 def GetEnumerator(self):
  """
  GetEnumerator(self: LinkedList[T]) -> Enumerator

  

   Returns an enumerator that iterates through the System.Collections.Generic.LinkedList.

   Returns: An System.Collections.Generic.LinkedList for the System.Collections.Generic.LinkedList.
  """
  pass
 def GetObjectData(self,info,context):
  """
  GetObjectData(self: LinkedList[T],info: SerializationInfo,context: StreamingContext)

   Implements the System.Runtime.Serialization.ISerializable interface and returns the data needed 

    to serialize the System.Collections.Generic.LinkedList instance.

  

  

   info: A System.Runtime.Serialization.SerializationInfo object that contains the information required 

    to serialize the System.Collections.Generic.LinkedList instance.

  

   context: A System.Runtime.Serialization.StreamingContext object that contains the source and destination 

    of the serialized stream associated with the System.Collections.Generic.LinkedList instance.
  """
  pass
 def OnDeserialization(self,sender):
  """
  OnDeserialization(self: LinkedList[T],sender: object)

   Implements the System.Runtime.Serialization.ISerializable interface and raises the 

    deserialization event when the deserialization is complete.

  

  

   sender: The source of the deserialization event.
  """
  pass
 def Remove(self,*__args):
  """
  Remove(self: LinkedList[T],node: LinkedListNode[T])

   Removes the specified node from the System.Collections.Generic.LinkedList.

  

   node: The System.Collections.Generic.LinkedListNode to remove from the 

    System.Collections.Generic.LinkedList.

  

  Remove(self: LinkedList[T],value: T) -> bool

  

   Removes the first occurrence of the specified value from the 

    System.Collections.Generic.LinkedList.

  

  

   value: The value to remove from the System.Collections.Generic.LinkedList.

   Returns: true if the element containing value is successfully removed; otherwise,false.  This method 

    also returns false if value was not found in the original System.Collections.Generic.LinkedList.
  """
  pass
 def RemoveFirst(self):
  """
  RemoveFirst(self: LinkedList[T])

   Removes the node at the start of the System.Collections.Generic.LinkedList.
  """
  pass
 def RemoveLast(self):
  """
  RemoveLast(self: LinkedList[T])

   Removes the node at the end of the System.Collections.Generic.LinkedList.
  """
  pass
 def __contains__(self,*args):
  """
  __contains__(self: ICollection[T],item: T) -> bool

  

   Determines whether the System.Collections.Generic.ICollection contains a specific value.

  

   item: The object to locate in the System.Collections.Generic.ICollection.

   Returns: true if item is found in the System.Collections.Generic.ICollection; otherwise,false.
  """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __iter__(self,*args):
  """ __iter__(self: IEnumerable) -> object """
  pass
 def __len__(self,*args):
  """ x.__len__() <==> len(x) """
  pass
 @staticmethod
 def __new__(self,collection=None):
  """
  __new__(cls: type)

  __new__(cls: type,collection: IEnumerable[T])

  __new__(cls: type,info: SerializationInfo,context: StreamingContext)
  """
  pass
 def __reduce_ex__(self,*args):
  pass
 def __repr__(self,*args):
  """ __repr__(self: object) -> str """
  pass
 Count=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets the number of nodes actually contained in the System.Collections.Generic.LinkedList.



Get: Count(self: LinkedList[T]) -> int



"""

 First=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets the first node of the System.Collections.Generic.LinkedList.



Get: First(self: LinkedList[T]) -> LinkedListNode[T]



"""

 Last=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets the last node of the System.Collections.Generic.LinkedList.



Get: Last(self: LinkedList[T]) -> LinkedListNode[T]



"""


 Enumerator=None


class LinkedListNode(object):
 """ LinkedListNode[T](value: T) """
 @staticmethod
 def __new__(self,value):
  """ __new__(cls: type,value: T) """
  pass
 List=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets the System.Collections.Generic.LinkedList that the System.Collections.Generic.LinkedListNode belongs to.



Get: List(self: LinkedListNode[T]) -> LinkedList[T]



"""

 Next=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets the next node in the System.Collections.Generic.LinkedList.



Get: Next(self: LinkedListNode[T]) -> LinkedListNode[T]



"""

 Previous=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets the previous node in the System.Collections.Generic.LinkedList.



Get: Previous(self: LinkedListNode[T]) -> LinkedListNode[T]



"""

 Value=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets the value contained in the node.



Get: Value(self: LinkedListNode[T]) -> T



Set: Value(self: LinkedListNode[T])=value

"""



class List(object,IList[T],ICollection[T],IEnumerable[T],IEnumerable,IList,ICollection,IReadOnlyList[T],IReadOnlyCollection[T]):
 """
 List[T]()

 List[T](capacity: int)

 List[T](collection: IEnumerable[T])
 """
 def Add(self,item):
  """
  Add(self: List[T],item: T)

   Adds an object to the end of the System.Collections.Generic.List.

  

   item: The object to be added to the end of the System.Collections.Generic.List. The value can be null 

    for reference types.
  """
  pass
 def AddRange(self,collection):
  """
  AddRange(self: List[T],collection: IEnumerable[T])

   Adds the elements of the specified collection to the end of the System.Collections.Generic.List.

  

   collection: The collection whose elements should be added to the end of the System.Collections.Generic.List. 

    The collection itself cannot be null,but it can contain elements that are null,if type T is a 

    reference type.
  """
  pass
 def AsReadOnly(self):
  """
  AsReadOnly(self: List[T]) -> ReadOnlyCollection[T]

  

   Returns a read-only System.Collections.Generic.IList wrapper for the current collection.

   Returns: A System.Collections.ObjectModel.ReadOnlyCollection that acts as a read-only wrapper around the 

    current System.Collections.Generic.List.
  """
  pass
 def BinarySearch(self,*__args):
  """
  BinarySearch(self: List[T],item: T,comparer: IComparer[T]) -> int

  

   Searches the entire sorted System.Collections.Generic.List for an element using the specified 

    comparer and returns the zero-based index of the element.

  

  

   item: The object to locate. The value can be null for reference types.

   comparer: The System.Collections.Generic.IComparer implementation to use when comparing elements.-or-null 

    to use the default comparer System.Collections.Generic.Comparer.

  

   Returns: The zero-based index of item in the sorted System.Collections.Generic.List,if item is found; 

    otherwise,a negative number that is the bitwise complement of the index of the next element 

    that is larger than item or,if there is no larger element,the bitwise complement of 

    System.Collections.Generic.List.

  

  BinarySearch(self: List[T],item: T) -> int

  

   Searches the entire sorted System.Collections.Generic.List for an element using the default 

    comparer and returns the zero-based index of the element.

  

  

   item: The object to locate. The value can be null for reference types.

   Returns: The zero-based index of item in the sorted System.Collections.Generic.List,if item is found; 

    otherwise,a negative number that is the bitwise complement of the index of the next element 

    that is larger than item or,if there is no larger element,the bitwise complement of 

    System.Collections.Generic.List.

  

  BinarySearch(self: List[T],index: int,count: int,item: T,comparer: IComparer[T]) -> int

  

   Searches a range of elements in the sorted System.Collections.Generic.List for an element using 

    the specified comparer and returns the zero-based index of the element.

  

  

   index: The zero-based starting index of the range to search.

   count: The length of the range to search.

   item: The object to locate. The value can be null for reference types.

   comparer: The System.Collections.Generic.IComparer implementation to use when comparing elements,or null 

    to use the default comparer System.Collections.Generic.Comparer.

  

   Returns: The zero-based index of item in the sorted System.Collections.Generic.List,if item is found; 

    otherwise,a negative number that is the bitwise complement of the index of the next element 

    that is larger than item or,if there is no larger element,the bitwise complement of 

    System.Collections.Generic.List.
  """
  pass
 def Clear(self):
  """
  Clear(self: List[T])

   Removes all elements from the System.Collections.Generic.List.
  """
  pass
 def Contains(self,item):
  """
  Contains(self: List[T],item: T) -> bool

  

   Determines whether an element is in the System.Collections.Generic.List.

  

   item: The object to locate in the System.Collections.Generic.List. The value can be null for reference 

    types.

  

   Returns: true if item is found in the System.Collections.Generic.List; otherwise,false.
  """
  pass
 def ConvertAll(self,converter):
  """ ConvertAll[TOutput](self: List[T],converter: Converter[T,TOutput]) -> List[TOutput] """
  pass
 def CopyTo(self,*__args):
  """ CopyTo(self: List[T],index: int,array: Array[T],arrayIndex: int,count: int)CopyTo(self: List[T],array: Array[T],arrayIndex: int)CopyTo(self: List[T],array: Array[T]) """
  pass
 def Exists(self,match):
  """
  Exists(self: List[T],match: Predicate[T]) -> bool

  

   Determines whether the System.Collections.Generic.List contains elements that match the 

    conditions defined by the specified predicate.

  

  

   match: The System.Predicate delegate that defines the conditions of the elements to search for.

   Returns: true if the System.Collections.Generic.List contains one or more elements that match the 

    conditions defined by the specified predicate; otherwise,false.
  """
  pass
 def Find(self,match):
  """
  Find(self: List[T],match: Predicate[T]) -> T

  

   Searches for an element that matches the conditions defined by the specified predicate,and 

    returns the first occurrence within the entire System.Collections.Generic.List.

  

  

   match: The System.Predicate delegate that defines the conditions of the element to search for.

   Returns: The first element that matches the conditions defined by the specified predicate,if found; 

    otherwise,the default value for type T.
  """
  pass
 def FindAll(self,match):
  """
  FindAll(self: List[T],match: Predicate[T]) -> List[T]

  

   Retrieves all the elements that match the conditions defined by the specified predicate.

  

   match: The System.Predicate delegate that defines the conditions of the elements to search for.

   Returns: A System.Collections.Generic.List containing all the elements that match the conditions defined 

    by the specified predicate,if found; otherwise,an empty System.Collections.Generic.List.
  """
  pass
 def FindIndex(self,*__args):
  """
  FindIndex(self: List[T],startIndex: int,match: Predicate[T]) -> int

  

   Searches for an element that matches the conditions defined by the specified predicate,and 

    returns the zero-based index of the first occurrence within the range of elements in the 

    System.Collections.Generic.List that extends from the specified index to the last element.

  

  

   startIndex: The zero-based starting index of the search.

   match: The System.Predicate delegate that defines the conditions of the element to search for.

   Returns: The zero-based index of the first occurrence of an element that matches the conditions defined 

    

  FindIndex(self: List[T],startIndex: int,count: int,match: Predicate[T]) -> int

  

   Searches for an element that matches the conditions defined by the specified predicate,and 

    returns the zero-based index of the first occurrence within the range of elements in the 

    System.Collections.Generic.List that starts at the specified index and contains the specified 

    number of elements.

  

  

   startIndex: The zero-based starting index of the search.

   count: The number of elements in the section to search.

   match: The System.Predicate delegate that defines the conditions of the element to search for.

   Returns: The zero-based index of the first occurrence of an element that matches the conditions defined 

    

  FindIndex(self: List[T],match: Predicate[T]) -> int

  

   Searches for an element that matches the conditions defined by the specified predicate,and 

    returns the zero-based index of the first occurrence within the entire 

    System.Collections.Generic.List.

  

  

   match: The System.Predicate delegate that defines the conditions of the element to search for.

   Returns: The zero-based index of the first occurrence of an element that matches the conditions defined 

    """
  pass
 def FindLast(self,match):
  """
  FindLast(self: List[T],match: Predicate[T]) -> T

  

   Searches for an element that matches the conditions defined by the specified predicate,and 

    returns the last occurrence within the entire System.Collections.Generic.List.

  

  

   match: The System.Predicate delegate that defines the conditions of the element to search for.

   Returns: The last element that matches the conditions defined by the specified predicate,if found; 

    otherwise,the default value for type T.
  """
  pass
 def FindLastIndex(self,*__args):
  """
  FindLastIndex(self: List[T],startIndex: int,count: int,match: Predicate[T]) -> int

  

   Searches for an element that matches the conditions defined by the specified predicate,and 

    returns the zero-based index of the last occurrence within the range of elements in the 

    System.Collections.Generic.List that contains the specified number of elements and ends at the 

    specified index.

  

  

   startIndex: The zero-based starting index of the backward search.

   count: The number of elements in the section to search.

   match: The System.Predicate delegate that defines the conditions of the element to search for.

   Returns: The zero-based index of the last occurrence of an element that matches the conditions defined by 

    

  FindLastIndex(self: List[T],startIndex: int,match: Predicate[T]) -> int

  

   Searches for an element that matches the conditions defined by the specified predicate,and 

    returns the zero-based index of the last occurrence within the range of elements in the 

    System.Collections.Generic.List that extends from the first element to the specified index.

  

  

   startIndex: The zero-based starting index of the backward search.

   match: The System.Predicate delegate that defines the conditions of the element to search for.

   Returns: The zero-based index of the last occurrence of an element that matches the conditions defined by 

    

  FindLastIndex(self: List[T],match: Predicate[T]) -> int

  

   Searches for an element that matches the conditions defined by the specified predicate,and 

    returns the zero-based index of the last occurrence within the entire 

    System.Collections.Generic.List.

  

  

   match: The System.Predicate delegate that defines the conditions of the element to search for.

   Returns: The zero-based index of the last occurrence of an element that matches the conditions defined by 

    """
  pass
 def ForEach(self,action):
  """
  ForEach(self: List[T],action: Action[T])

   Performs the specified action on each element of the System.Collections.Generic.List.

  

   action: The System.Action delegate to perform on each element of the System.Collections.Generic.List.
  """
  pass
 def GetEnumerator(self):
  """
  GetEnumerator(self: List[T]) -> Enumerator

  

   Returns an enumerator that iterates through the System.Collections.Generic.List.

   Returns: A System.Collections.Generic.List for the System.Collections.Generic.List.
  """
  pass
 def GetRange(self,index,count):
  """
  GetRange(self: List[T],index: int,count: int) -> List[T]

  

   Creates a shallow copy of a range of elements in the source System.Collections.Generic.List.

  

   index: The zero-based System.Collections.Generic.List index at which the range starts.

   count: The number of elements in the range.

   Returns: A shallow copy of a range of elements in the source System.Collections.Generic.List.
  """
  pass
 def IndexOf(self,item,index=None,count=None):
  """
  IndexOf(self: List[T],item: T,index: int,count: int) -> int

  

   Searches for the specified object and returns the zero-based index of the first occurrence 

    within the range of elements in the System.Collections.Generic.List that starts at the specified 

    index and contains the specified number of elements.

  

  

   item: The object to locate in the System.Collections.Generic.List. The value can be null for reference 

    types.

  

   index: The zero-based starting index of the search. 0 (zero) is valid in an empty list.

   count: The number of elements in the section to search.

   Returns: The zero-based index of the first occurrence of item within the range of elements in the 

    System.Collections.Generic.List that starts at index and contains count number of elements,if 

    

  IndexOf(self: List[T],item: T,index: int) -> int

  

   Searches for the specified object and returns the zero-based index of the first occurrence 

    within the range of elements in the System.Collections.Generic.List that extends from the 

    specified index to the last element.

  

  

   item: The object to locate in the System.Collections.Generic.List. The value can be null for reference 

    types.

  

   index: The zero-based starting index of the search. 0 (zero) is valid in an empty list.

   Returns: The zero-based index of the first occurrence of item within the range of elements in the 

    System.Collections.Generic.List that extends from index to the last element,if found; 

    

  IndexOf(self: List[T],item: T) -> int

  

   Searches for the specified object and returns the zero-based index of the first occurrence 

    within the entire System.Collections.Generic.List.

  

  

   item: The object to locate in the System.Collections.Generic.List. The value can be null for reference 

    types.

  

   Returns: The zero-based index of the first occurrence of item within the entire 

    """
  pass
 def Insert(self,index,item):
  """
  Insert(self: List[T],index: int,item: T)

   Inserts an element into the System.Collections.Generic.List at the specified index.

  

   index: The zero-based index at which item should be inserted.

   item: The object to insert. The value can be null for reference types.
  """
  pass
 def InsertRange(self,index,collection):
  """
  InsertRange(self: List[T],index: int,collection: IEnumerable[T])

   Inserts the elements of a collection into the System.Collections.Generic.List at the specified 

    index.

  

  

   index: The zero-based index at which the new elements should be inserted.

   collection: The collection whose elements should be inserted into the System.Collections.Generic.List. The 

    collection itself cannot be null,but it can contain elements that are null,if type T is a 

    reference type.
  """
  pass
 def LastIndexOf(self,item,index=None,count=None):
  """
  LastIndexOf(self: List[T],item: T,index: int) -> int

  

   Searches for the specified object and returns the zero-based index of the last occurrence within 

    the range of elements in the System.Collections.Generic.List that extends from the first element 

    to the specified index.

  

  

   item: The object to locate in the System.Collections.Generic.List. The value can be null for reference 

    types.

  

   index: The zero-based starting index of the backward search.

   Returns: The zero-based index of the last occurrence of item within the range of elements in the 

    System.Collections.Generic.List that extends from the first element to index,if found; 

    

  LastIndexOf(self: List[T],item: T) -> int

  

   Searches for the specified object and returns the zero-based index of the last occurrence within 

    the entire System.Collections.Generic.List.

  

  

   item: The object to locate in the System.Collections.Generic.List. The value can be null for reference 

    types.

  

   Returns: The zero-based index of the last occurrence of item within the entire the 

    

  LastIndexOf(self: List[T],item: T,index: int,count: int) -> int

  

   Searches for the specified object and returns the zero-based index of the last occurrence within 

    the range of elements in the System.Collections.Generic.List that contains the specified number 

    of elements and ends at the specified index.

  

  

   item: The object to locate in the System.Collections.Generic.List. The value can be null for reference 

    types.

  

   index: The zero-based starting index of the backward search.

   count: The number of elements in the section to search.

   Returns: The zero-based index of the last occurrence of item within the range of elements in the 

    System.Collections.Generic.List that contains count number of elements and ends at index,if 

    """
  pass
 def Remove(self,item):
  """
  Remove(self: List[T],item: T) -> bool

  

   Removes the first occurrence of a specific object from the System.Collections.Generic.List.

  

   item: The object to remove from the System.Collections.Generic.List. The value can be null for 

    reference types.

  

   Returns: true if item is successfully removed; otherwise,false.  This method also returns false if item 

    was not found in the System.Collections.Generic.List.
  """
  pass
 def RemoveAll(self,match):
  """
  RemoveAll(self: List[T],match: Predicate[T]) -> int

  

   Removes all the elements that match the conditions defined by the specified predicate.

  

   match: The System.Predicate delegate that defines the conditions of the elements to remove.

   Returns: The number of elements removed from the System.Collections.Generic.List .
  """
  pass
 def RemoveAt(self,index):
  """
  RemoveAt(self: List[T],index: int)

   Removes the element at the specified index of the System.Collections.Generic.List.

  

   index: The zero-based index of the element to remove.
  """
  pass
 def RemoveRange(self,index,count):
  """
  RemoveRange(self: List[T],index: int,count: int)

   Removes a range of elements from the System.Collections.Generic.List.

  

   index: The zero-based starting index of the range of elements to remove.

   count: The number of elements to remove.
  """
  pass
 def Reverse(self,index=None,count=None):
  """
  Reverse(self: List[T],index: int,count: int)

   Reverses the order of the elements in the specified range.

  

   index: The zero-based starting index of the range to reverse.

   count: The number of elements in the range to reverse.

  Reverse(self: List[T])

   Reverses the order of the elements in the entire System.Collections.Generic.List.
  """
  pass
 def Sort(self,*__args):
  """
  Sort(self: List[T],index: int,count: int,comparer: IComparer[T])

   Sorts the elements in a range of elements in System.Collections.Generic.List using the specified 

    comparer.

  

  

   index: The zero-based starting index of the range to sort.

   count: The length of the range to sort.

   comparer: The System.Collections.Generic.IComparer implementation to use when comparing elements,or null 

    to use the default comparer System.Collections.Generic.Comparer.

  

  Sort(self: List[T],comparison: Comparison[T])

   Sorts the elements in the entire System.Collections.Generic.List using the specified 

    System.Comparison.

  

  

   comparison: The System.Comparison to use when comparing elements.

  Sort(self: List[T])

   Sorts the elements in the entire System.Collections.Generic.List using the default comparer.

  Sort(self: List[T],comparer: IComparer[T])

   Sorts the elements in the entire System.Collections.Generic.List using the specified comparer.

  

   comparer: The System.Collections.Generic.IComparer implementation to use when comparing elements,or null 

    to use the default comparer System.Collections.Generic.Comparer.
  """
  pass
 def ToArray(self):
  """
  ToArray(self: List[T]) -> Array[T]

  

   Copies the elements of the System.Collections.Generic.List to a new array.

   Returns: An array containing copies of the elements of the System.Collections.Generic.List.
  """
  pass
 def TrimExcess(self):
  """
  TrimExcess(self: List[T])

   Sets the capacity to the actual number of elements in the System.Collections.Generic.List,if 

    that number is less than a threshold value.
  """
  pass
 def TrueForAll(self,match):
  """
  TrueForAll(self: List[T],match: Predicate[T]) -> bool

  

   Determines whether every element in the System.Collections.Generic.List matches the conditions 

    defined by the specified predicate.

  

  

   match: The System.Predicate delegate that defines the conditions to check against the elements.

   Returns: true if every element in the System.Collections.Generic.List matches the conditions defined by 

    the specified predicate; otherwise,false. If the list has no elements,the return value is 

    true.
  """
  pass
 def __add__(self,*args):
  """ x.__add__(y) <==> x+y """
  pass
 def __contains__(self,*args):
  """
  __contains__(self: ICollection[T],item: T) -> bool

  

   Determines whether the System.Collections.Generic.ICollection contains a specific value.

  

   item: The object to locate in the System.Collections.Generic.ICollection.

   Returns: true if item is found in the System.Collections.Generic.ICollection; otherwise,false.

  __contains__(self: IList,value: object) -> bool

  

   Determines whether the System.Collections.IList contains a specific value.

  

   value: The object to locate in the System.Collections.IList.

   Returns: true if the System.Object is found in the System.Collections.IList; otherwise,false.
  """
  pass
 def __getitem__(self,*args):
  """ x.__getitem__(y) <==> x[y] """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __iter__(self,*args):
  """ __iter__(self: IEnumerable) -> object """
  pass
 def __len__(self,*args):
  """ x.__len__() <==> len(x) """
  pass
 @staticmethod
 def __new__(self,*__args):
  """
  __new__(cls: type)

  __new__(cls: type,capacity: int)

  __new__(cls: type,collection: IEnumerable[T])
  """
  pass
 def __reduce_ex__(self,*args):
  pass
 def __repr__(self,*args):
  """
  __repr__(self: List[T]) -> str

  __repr__(self: List[T]) -> str
  """
  pass
 def __setitem__(self,*args):
  """ x.__setitem__(i,y) <==> x[i]= """
  pass
 Capacity=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets or sets the total number of elements the internal data structure can hold without resizing.



Get: Capacity(self: List[T]) -> int



Set: Capacity(self: List[T])=value

"""

 Count=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets the number of elements actually contained in the System.Collections.Generic.List.



Get: Count(self: List[T]) -> int



"""


 Enumerator=None


class Queue(object,IEnumerable[T],IEnumerable,ICollection,IReadOnlyCollection[T]):
 """
 Queue[T]()

 Queue[T](capacity: int)

 Queue[T](collection: IEnumerable[T])
 """
 def Clear(self):
  """
  Clear(self: Queue[T])

   Removes all objects from the System.Collections.Generic.Queue.
  """
  pass
 def Contains(self,item):
  """
  Contains(self: Queue[T],item: T) -> bool

  

   Determines whether an element is in the System.Collections.Generic.Queue.

  

   item: The object to locate in the System.Collections.Generic.Queue. The value can be null for 

    reference types.

  

   Returns: true if item is found in the System.Collections.Generic.Queue; otherwise,false.
  """
  pass
 def CopyTo(self,array,arrayIndex):
  """ CopyTo(self: Queue[T],array: Array[T],arrayIndex: int) """
  pass
 def Dequeue(self):
  """
  Dequeue(self: Queue[T]) -> T

  

   Removes and returns the object at the beginning of the System.Collections.Generic.Queue.

   Returns: The object that is removed from the beginning of the System.Collections.Generic.Queue.
  """
  pass
 def Enqueue(self,item):
  """
  Enqueue(self: Queue[T],item: T)

   Adds an object to the end of the System.Collections.Generic.Queue.

  

   item: The object to add to the System.Collections.Generic.Queue. The value can be null for reference 

    types.
  """
  pass
 def GetEnumerator(self):
  """
  GetEnumerator(self: Queue[T]) -> Enumerator

  

   Returns an enumerator that iterates through the System.Collections.Generic.Queue.

   Returns: An System.Collections.Generic.Queue for the System.Collections.Generic.Queue.
  """
  pass
 def Peek(self):
  """
  Peek(self: Queue[T]) -> T

  

   Returns the object at the beginning of the System.Collections.Generic.Queue without removing it.

   Returns: The object at the beginning of the System.Collections.Generic.Queue.
  """
  pass
 def ToArray(self):
  """
  ToArray(self: Queue[T]) -> Array[T]

  

   Copies the System.Collections.Generic.Queue elements to a new array.

   Returns: A new array containing elements copied from the System.Collections.Generic.Queue.
  """
  pass
 def TrimExcess(self):
  """
  TrimExcess(self: Queue[T])

   Sets the capacity to the actual number of elements in the System.Collections.Generic.Queue,if 

    that number is less than 90 percent of current capacity.
  """
  pass
 def __contains__(self,*args):
  """ __contains__[T](enumerable: IEnumerable[T],value: T) -> bool """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __iter__(self,*args):
  """ __iter__(self: IEnumerable) -> object """
  pass
 def __len__(self,*args):
  """ x.__len__() <==> len(x) """
  pass
 @staticmethod
 def __new__(self,*__args):
  """
  __new__(cls: type)

  __new__(cls: type,capacity: int)

  __new__(cls: type,collection: IEnumerable[T])
  """
  pass
 def __reduce_ex__(self,*args):
  pass
 def __repr__(self,*args):
  """ __repr__(self: object) -> str """
  pass
 Count=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets the number of elements contained in the System.Collections.Generic.Queue.



Get: Count(self: Queue[T]) -> int



"""


 Enumerator=None


class SortedDictionary(object,IDictionary[TKey,TValue],ICollection[KeyValuePair[TKey,TValue]],IEnumerable[KeyValuePair[TKey,TValue]],IEnumerable,IDictionary,ICollection,IReadOnlyDictionary[TKey,TValue],IReadOnlyCollection[KeyValuePair[TKey,TValue]]):
 """
 SortedDictionary[TKey,TValue]()

 SortedDictionary[TKey,TValue](comparer: IComparer[TKey])

 SortedDictionary[TKey,TValue](dictionary: IDictionary[TKey,TValue])

 SortedDictionary[TKey,TValue](dictionary: IDictionary[TKey,TValue],comparer: IComparer[TKey])
 """
 def Add(self,key,value):
  """
  Add(self: SortedDictionary[TKey,TValue],key: TKey,value: TValue)

   Adds an element with the specified key and value into the 

    System.Collections.Generic.SortedDictionary.

  

  

   key: The key of the element to add.

   value: The value of the element to add. The value can be null for reference types.
  """
  pass
 def Clear(self):
  """
  Clear(self: SortedDictionary[TKey,TValue])

   Removes all elements from the System.Collections.Generic.SortedDictionary.
  """
  pass
 def ContainsKey(self,key):
  """
  ContainsKey(self: SortedDictionary[TKey,TValue],key: TKey) -> bool

  

   Determines whether the System.Collections.Generic.SortedDictionary contains an element with the 

    specified key.

  

  

   key: The key to locate in the System.Collections.Generic.SortedDictionary.

   Returns: true if the System.Collections.Generic.SortedDictionary contains an element with the specified 

    key; otherwise,false.
  """
  pass
 def ContainsValue(self,value):
  """
  ContainsValue(self: SortedDictionary[TKey,TValue],value: TValue) -> bool

  

   Determines whether the System.Collections.Generic.SortedDictionary contains an element with the 

    specified value.

  

  

   value: The value to locate in the System.Collections.Generic.SortedDictionary. The value can be null 

    for reference types.

  

   Returns: true if the System.Collections.Generic.SortedDictionary contains an element with the specified 

    value; otherwise,false.
  """
  pass
 def CopyTo(self,array,index):
  """ CopyTo(self: SortedDictionary[TKey,TValue],array: Array[KeyValuePair[TKey,TValue]],index: int) """
  pass
 def GetEnumerator(self):
  """
  GetEnumerator(self: SortedDictionary[TKey,TValue]) -> Enumerator

  

   Returns an enumerator that iterates through the System.Collections.Generic.SortedDictionary.

   Returns: A System.Collections.Generic.SortedDictionary for the 

    System.Collections.Generic.SortedDictionary.
  """
  pass
 def Remove(self,key):
  """
  Remove(self: SortedDictionary[TKey,TValue],key: TKey) -> bool

  

   Removes the element with the specified key from the System.Collections.Generic.SortedDictionary.

  

   key: The key of the element to remove.

   Returns: true if the element is successfully removed; otherwise,false.  This method also returns false 

    if key is not found in the System.Collections.Generic.SortedDictionary.
  """
  pass
 def TryGetValue(self,key,value):
  """ TryGetValue(self: SortedDictionary[TKey,TValue],key: TKey) -> (bool,TValue) """
  pass
 def __add__(self,*args):
  """ x.__add__(y) <==> x+y """
  pass
 def __contains__(self,*args):
  """
  __contains__(self: IDictionary[TKey,TValue],key: TKey) -> bool

  

   Determines whether the System.Collections.Generic.IDictionary contains an element with the 

    specified key.

  

  

   key: The key to locate in the System.Collections.Generic.IDictionary.

   Returns: true if the System.Collections.Generic.IDictionary contains an element with the key; otherwise,

    false.

  

  __contains__(self: IDictionary,key: object) -> bool

  

   Determines whether the System.Collections.IDictionary object contains an element with the 

    specified key.

  

  

   key: The key to locate in the System.Collections.IDictionary object.

   Returns: true if the System.Collections.IDictionary contains an element with the key; otherwise,false.
  """
  pass
 def __getitem__(self,*args):
  """ x.__getitem__(y) <==> x[y] """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __iter__(self,*args):
  """ __iter__(self: IEnumerable) -> object """
  pass
 def __len__(self,*args):
  """ x.__len__() <==> len(x) """
  pass
 @staticmethod
 def __new__(self,*__args):
  """
  __new__(cls: type)

  __new__(cls: type,dictionary: IDictionary[TKey,TValue])

  __new__(cls: type,dictionary: IDictionary[TKey,TValue],comparer: IComparer[TKey])

  __new__(cls: type,comparer: IComparer[TKey])
  """
  pass
 def __reduce_ex__(self,*args):
  pass
 def __repr__(self,*args):
  """ __repr__(self: object) -> str """
  pass
 def __setitem__(self,*args):
  """ x.__setitem__(i,y) <==> x[i]= """
  pass
 Comparer=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets the System.Collections.Generic.IComparer used to order the elements of the System.Collections.Generic.SortedDictionary.



Get: Comparer(self: SortedDictionary[TKey,TValue]) -> IComparer[TKey]



"""

 Count=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets the number of key/value pairs contained in the System.Collections.Generic.SortedDictionary.



Get: Count(self: SortedDictionary[TKey,TValue]) -> int



"""

 Keys=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets a collection containing the keys in the System.Collections.Generic.SortedDictionary.



Get: Keys(self: SortedDictionary[TKey,TValue]) -> KeyCollection



"""

 Values=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets a collection containing the values in the System.Collections.Generic.SortedDictionary.



Get: Values(self: SortedDictionary[TKey,TValue]) -> ValueCollection



"""


 Enumerator=None
 KeyCollection=None
 ValueCollection=None


class SortedList(object,IDictionary[TKey,TValue],ICollection[KeyValuePair[TKey,TValue]],IEnumerable[KeyValuePair[TKey,TValue]],IEnumerable,IDictionary,ICollection,IReadOnlyDictionary[TKey,TValue],IReadOnlyCollection[KeyValuePair[TKey,TValue]]):
 """
 SortedList[TKey,TValue]()

 SortedList[TKey,TValue](capacity: int)

 SortedList[TKey,TValue](comparer: IComparer[TKey])

 SortedList[TKey,TValue](capacity: int,comparer: IComparer[TKey])

 SortedList[TKey,TValue](dictionary: IDictionary[TKey,TValue])

 SortedList[TKey,TValue](dictionary: IDictionary[TKey,TValue],comparer: IComparer[TKey])
 """
 def Add(self,key,value):
  """
  Add(self: SortedList[TKey,TValue],key: TKey,value: TValue)

   Adds an element with the specified key and value into the System.Collections.Generic.SortedList.

  

   key: The key of the element to add.

   value: The value of the element to add. The value can be null for reference types.
  """
  pass
 def Clear(self):
  """
  Clear(self: SortedList[TKey,TValue])

   Removes all elements from the System.Collections.Generic.SortedList.
  """
  pass
 def ContainsKey(self,key):
  """
  ContainsKey(self: SortedList[TKey,TValue],key: TKey) -> bool

  

   Determines whether the System.Collections.Generic.SortedList contains a specific key.

  

   key: The key to locate in the System.Collections.Generic.SortedList.

   Returns: true if the System.Collections.Generic.SortedList contains an element with the specified key; 

    otherwise,false.
  """
  pass
 def ContainsValue(self,value):
  """
  ContainsValue(self: SortedList[TKey,TValue],value: TValue) -> bool

  

   Determines whether the System.Collections.Generic.SortedList contains a specific value.

  

   value: The value to locate in the System.Collections.Generic.SortedList. The value can be null for 

    reference types.

  

   Returns: true if the System.Collections.Generic.SortedList contains an element with the specified value; 

    otherwise,false.
  """
  pass
 def GetEnumerator(self):
  """
  GetEnumerator(self: SortedList[TKey,TValue]) -> IEnumerator[KeyValuePair[TKey,TValue]]

  

   Returns an enumerator that iterates through the System.Collections.Generic.SortedList.

   Returns: An System.Collections.Generic.IEnumerator of type System.Collections.Generic.KeyValuePair for 

    the System.Collections.Generic.SortedList.
  """
  pass
 def IndexOfKey(self,key):
  """
  IndexOfKey(self: SortedList[TKey,TValue],key: TKey) -> int

  

   Searches for the specified key and returns the zero-based index within the entire 

    System.Collections.Generic.SortedList.

  

  

   key: The key to locate in the System.Collections.Generic.SortedList.

   Returns: The zero-based index of key within the entire System.Collections.Generic.SortedList,if found; 

    otherwise,-1.
  """
  pass
 def IndexOfValue(self,value):
  """
  IndexOfValue(self: SortedList[TKey,TValue],value: TValue) -> int

  

   Searches for the specified value and returns the zero-based index of the first occurrence within 

    the entire System.Collections.Generic.SortedList.

  

  

   value: The value to locate in the System.Collections.Generic.SortedList.  The value can be null for 

    reference types.

  

   Returns: The zero-based index of the first occurrence of value within the entire 

    System.Collections.Generic.SortedList,if found; otherwise,-1.
  """
  pass
 def Remove(self,key):
  """
  Remove(self: SortedList[TKey,TValue],key: TKey) -> bool

  

   Removes the element with the specified key from the System.Collections.Generic.SortedList.

  

   key: The key of the element to remove.

   Returns: true if the element is successfully removed; otherwise,false.  This method also returns false 

    if key was not found in the original System.Collections.Generic.SortedList.
  """
  pass
 def RemoveAt(self,index):
  """
  RemoveAt(self: SortedList[TKey,TValue],index: int)

   Removes the element at the specified index of the System.Collections.Generic.SortedList.

  

   index: The zero-based index of the element to remove.
  """
  pass
 def TrimExcess(self):
  """
  TrimExcess(self: SortedList[TKey,TValue])

   Sets the capacity to the actual number of elements in the System.Collections.Generic.SortedList,

    if that number is less than 90 percent of current capacity.
  """
  pass
 def TryGetValue(self,key,value):
  """ TryGetValue(self: SortedList[TKey,TValue],key: TKey) -> (bool,TValue) """
  pass
 def __add__(self,*args):
  """ x.__add__(y) <==> x+y """
  pass
 def __contains__(self,*args):
  """
  __contains__(self: IDictionary[TKey,TValue],key: TKey) -> bool

  

   Determines whether the System.Collections.Generic.IDictionary contains an element with the 

    specified key.

  

  

   key: The key to locate in the System.Collections.Generic.IDictionary.

   Returns: true if the System.Collections.Generic.IDictionary contains an element with the key; otherwise,

    false.

  

  __contains__(self: IDictionary,key: object) -> bool

  

   Determines whether the System.Collections.IDictionary object contains an element with the 

    specified key.

  

  

   key: The key to locate in the System.Collections.IDictionary object.

   Returns: true if the System.Collections.IDictionary contains an element with the key; otherwise,false.
  """
  pass
 def __getitem__(self,*args):
  """ x.__getitem__(y) <==> x[y] """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __iter__(self,*args):
  """ __iter__(self: IEnumerable) -> object """
  pass
 def __len__(self,*args):
  """ x.__len__() <==> len(x) """
  pass
 @staticmethod
 def __new__(self,*__args):
  """
  __new__(cls: type)

  __new__(cls: type,capacity: int)

  __new__(cls: type,comparer: IComparer[TKey])

  __new__(cls: type,capacity: int,comparer: IComparer[TKey])

  __new__(cls: type,dictionary: IDictionary[TKey,TValue])

  __new__(cls: type,dictionary: IDictionary[TKey,TValue],comparer: IComparer[TKey])
  """
  pass
 def __reduce_ex__(self,*args):
  pass
 def __repr__(self,*args):
  """ __repr__(self: object) -> str """
  pass
 def __setitem__(self,*args):
  """ x.__setitem__(i,y) <==> x[i]= """
  pass
 Capacity=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets or sets the number of elements that the System.Collections.Generic.SortedList can contain.



Get: Capacity(self: SortedList[TKey,TValue]) -> int



Set: Capacity(self: SortedList[TKey,TValue])=value

"""

 Comparer=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets the System.Collections.Generic.IComparer for the sorted list.



Get: Comparer(self: SortedList[TKey,TValue]) -> IComparer[TKey]



"""

 Count=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets the number of key/value pairs contained in the System.Collections.Generic.SortedList.



Get: Count(self: SortedList[TKey,TValue]) -> int



"""

 Keys=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets a collection containing the keys in the System.Collections.Generic.SortedList.



Get: Keys(self: SortedList[TKey,TValue]) -> IList[TKey]



"""

 Values=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets a collection containing the values in the System.Collections.Generic.SortedList.



Get: Values(self: SortedList[TKey,TValue]) -> IList[TValue]



"""



class SortedSet(object,ISet[T],ICollection[T],IEnumerable[T],IEnumerable,ICollection,ISerializable,IDeserializationCallback,IReadOnlyCollection[T]):
 """
 SortedSet[T]()

 SortedSet[T](collection: IEnumerable[T])

 SortedSet[T](collection: IEnumerable[T],comparer: IComparer[T])

 SortedSet[T](comparer: IComparer[T])
 """
 def Add(self,item):
  """
  Add(self: SortedSet[T],item: T) -> bool

  

   Adds an element to the set and returns a value that indicates if it was successfully added.

  

   item: The element to add to the set.

   Returns: true if item is added to the set; otherwise,false.
  """
  pass
 def Clear(self):
  """
  Clear(self: SortedSet[T])

   Removes all elements from the set.
  """
  pass
 def Contains(self,item):
  """
  Contains(self: SortedSet[T],item: T) -> bool

  

   Determines whether the set contains a specific element.

  

   item: The element to locate in the set.

   Returns: true if the set contains item; otherwise,false.
  """
  pass
 def CopyTo(self,array,index=None,count=None):
  """ CopyTo(self: SortedSet[T],array: Array[T],index: int,count: int)CopyTo(self: SortedSet[T],array: Array[T],index: int)CopyTo(self: SortedSet[T],array: Array[T]) """
  pass
 @staticmethod
 def CreateSetComparer(memberEqualityComparer=None):
  """
  CreateSetComparer(memberEqualityComparer: IEqualityComparer[T]) -> IEqualityComparer[SortedSet[T]]

  

   Returns an System.Collections.IEqualityComparer object,according to a specified comparer,that 

    can be used to create a collection that contains individual sets.

  

  

   memberEqualityComparer: The comparer to use for creating the returned comparer.

   Returns: A comparer for creating a collection of sets.

  CreateSetComparer() -> IEqualityComparer[SortedSet[T]]

  

   Returns an System.Collections.IEqualityComparer object that can be used to create a collection 

    that contains individual sets.

  

   Returns: A comparer for creating a collection of sets.
  """
  pass
 def ExceptWith(self,other):
  """
  ExceptWith(self: SortedSet[T],other: IEnumerable[T])

   Removes all elements that are in a specified collection from the current 

    System.Collections.Generic.SortedSet object.

  

  

   other: The collection of items to remove from the System.Collections.Generic.SortedSet object.
  """
  pass
 def GetEnumerator(self):
  """
  GetEnumerator(self: SortedSet[T]) -> Enumerator

  

   Returns an enumerator that iterates through the System.Collections.Generic.SortedSet.

   Returns: An enumerator that iterates through the System.Collections.Generic.SortedSet.
  """
  pass
 def GetObjectData(self,*args):
  """
  GetObjectData(self: SortedSet[T],info: SerializationInfo,context: StreamingContext)

   Implements the System.Runtime.Serialization.ISerializable interface and returns the data that 

    you must have to serialize a System.Collections.Generic.SortedSet object.

  

  

   info: A System.Runtime.Serialization.SerializationInfo object that contains the information that is 

    required to serialize the System.Collections.Generic.SortedSet object.

  

   context: A System.Runtime.Serialization.StreamingContext structure that contains the source and 

    destination of the serialized stream associated with the System.Collections.Generic.SortedSet 

    object.
  """
  pass
 def GetViewBetween(self,lowerValue,upperValue):
  """
  GetViewBetween(self: SortedSet[T],lowerValue: T,upperValue: T) -> SortedSet[T]

  

   Returns a view of a subset in a System.Collections.Generic.SortedSet.

  

   lowerValue: The lowest desired value in the view.

   upperValue: The highest desired value in the view.

   Returns: A subset view that contains only the values in the specified range.
  """
  pass
 def IntersectWith(self,other):
  """
  IntersectWith(self: SortedSet[T],other: IEnumerable[T])

   Modifies the current System.Collections.Generic.SortedSet object so that it contains only 

    elements that are also in a specified collection.

  

  

   other: The collection to compare to the current System.Collections.Generic.SortedSet object.
  """
  pass
 def IsProperSubsetOf(self,other):
  """
  IsProperSubsetOf(self: SortedSet[T],other: IEnumerable[T]) -> bool

  

   Determines whether a System.Collections.Generic.SortedSet object is a proper subset of the 

    specified collection.

  

  

   other: The collection to compare to the current System.Collections.Generic.SortedSet object.

   Returns: true if the System.Collections.Generic.SortedSet object is a proper subset of other; otherwise,

    false.
  """
  pass
 def IsProperSupersetOf(self,other):
  """
  IsProperSupersetOf(self: SortedSet[T],other: IEnumerable[T]) -> bool

  

   Determines whether a System.Collections.Generic.SortedSet object is a proper superset of the 

    specified collection.

  

  

   other: The collection to compare to the current System.Collections.Generic.SortedSet object.

   Returns: true if the System.Collections.Generic.SortedSet object is a proper superset of other; 

    otherwise,false.
  """
  pass
 def IsSubsetOf(self,other):
  """
  IsSubsetOf(self: SortedSet[T],other: IEnumerable[T]) -> bool

  

   Determines whether a System.Collections.Generic.SortedSet object is a subset of the specified 

    collection.

  

  

   other: The collection to compare to the current System.Collections.Generic.SortedSet object.

   Returns: true if the current System.Collections.Generic.SortedSet object is a subset of other; otherwise,

    false.
  """
  pass
 def IsSupersetOf(self,other):
  """
  IsSupersetOf(self: SortedSet[T],other: IEnumerable[T]) -> bool

  

   Determines whether a System.Collections.Generic.SortedSet object is a superset of the specified 

    collection.

  

  

   other: The collection to compare to the current System.Collections.Generic.SortedSet object.

   Returns: true if the System.Collections.Generic.SortedSet object is a superset of other; otherwise,false.
  """
  pass
 def OnDeserialization(self,*args):
  """
  OnDeserialization(self: SortedSet[T],sender: object)

   Implements the System.Runtime.Serialization.ISerializable interface,and raises the 

    deserialization event when the deserialization is completed.

  

  

   sender: The source of the deserialization event.
  """
  pass
 def Overlaps(self,other):
  """
  Overlaps(self: SortedSet[T],other: IEnumerable[T]) -> bool

  

   Determines whether the current System.Collections.Generic.SortedSet object and a specified 

    collection share common elements.

  

  

   other: The collection to compare to the current System.Collections.Generic.SortedSet object.

   Returns: true if the System.Collections.Generic.SortedSet object and other share at least one common 

    element; otherwise,false.
  """
  pass
 def Remove(self,item):
  """
  Remove(self: SortedSet[T],item: T) -> bool

  

   Removes a specified item from the System.Collections.Generic.SortedSet.

  

   item: The element to remove.

   Returns: true if the element is found and successfully removed; otherwise,false.
  """
  pass
 def RemoveWhere(self,match):
  """
  RemoveWhere(self: SortedSet[T],match: Predicate[T]) -> int

  

   Removes all elements that match the conditions defined by the specified predicate from a 

    System.Collections.Generic.SortedSet.

  

  

   match: The delegate that defines the conditions of the elements to remove.

   Returns: The number of elements that were removed from the System.Collections.Generic.SortedSet 

    collection..
  """
  pass
 def Reverse(self):
  """
  Reverse(self: SortedSet[T]) -> IEnumerable[T]

  

   Returns an System.Collections.Generic.IEnumerable that iterates over the 

    System.Collections.Generic.SortedSet in reverse order.

  

   Returns: An enumerator that iterates over the System.Collections.Generic.SortedSet in reverse order.
  """
  pass
 def SetEquals(self,other):
  """
  SetEquals(self: SortedSet[T],other: IEnumerable[T]) -> bool

  

   Determines whether the current System.Collections.Generic.SortedSet object and the specified 

    collection contain the same elements.

  

  

   other: The collection to compare to the current System.Collections.Generic.SortedSet object.

   Returns: true if the current System.Collections.Generic.SortedSet object is equal to other; otherwise,

    false.
  """
  pass
 def SymmetricExceptWith(self,other):
  """
  SymmetricExceptWith(self: SortedSet[T],other: IEnumerable[T])

   Modifies the current System.Collections.Generic.SortedSet object so that it contains only 

    elements that are present either in the current object or in the specified collection,but not 

    both.

  

  

   other: The collection to compare to the current System.Collections.Generic.SortedSet object.
  """
  pass
 def UnionWith(self,other):
  """
  UnionWith(self: SortedSet[T],other: IEnumerable[T])

   Modifies the current System.Collections.Generic.SortedSet object so that it contains all 

    elements that are present in both the current object and in the specified collection.

  

  

   other: The collection to compare to the current System.Collections.Generic.SortedSet object.
  """
  pass
 def __add__(self,*args):
  """ x.__add__(y) <==> x+y """
  pass
 def __contains__(self,*args):
  """
  __contains__(self: ICollection[T],item: T) -> bool

  

   Determines whether the System.Collections.Generic.ICollection contains a specific value.

  

   item: The object to locate in the System.Collections.Generic.ICollection.

   Returns: true if item is found in the System.Collections.Generic.ICollection; otherwise,false.
  """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __iter__(self,*args):
  """ __iter__(self: IEnumerable) -> object """
  pass
 def __len__(self,*args):
  """ x.__len__() <==> len(x) """
  pass
 @staticmethod
 def __new__(self,*__args):
  """
  __new__(cls: type)

  __new__(cls: type,comparer: IComparer[T])

  __new__(cls: type,collection: IEnumerable[T])

  __new__(cls: type,collection: IEnumerable[T],comparer: IComparer[T])

  __new__(cls: type,info: SerializationInfo,context: StreamingContext)
  """
  pass
 def __reduce_ex__(self,*args):
  pass
 def __repr__(self,*args):
  """ __repr__(self: object) -> str """
  pass
 Comparer=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets the System.Collections.Generic.IEqualityComparer object that is used to determine equality for the values in the System.Collections.Generic.SortedSet.



Get: Comparer(self: SortedSet[T]) -> IComparer[T]



"""

 Count=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets the number of elements in the System.Collections.Generic.SortedSet.



Get: Count(self: SortedSet[T]) -> int



"""

 Max=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets the maximum value in the System.Collections.Generic.SortedSet,as defined by the comparer.



Get: Max(self: SortedSet[T]) -> T



"""

 Min=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets the minimum value in the System.Collections.Generic.SortedSet,as defined by the comparer.



Get: Min(self: SortedSet[T]) -> T



"""


 Enumerator=None


class Stack(object,IEnumerable[T],IEnumerable,ICollection,IReadOnlyCollection[T]):
 """
 Stack[T]()

 Stack[T](capacity: int)

 Stack[T](collection: IEnumerable[T])
 """
 def Clear(self):
  """
  Clear(self: Stack[T])

   Removes all objects from the System.Collections.Generic.Stack.
  """
  pass
 def Contains(self,item):
  """
  Contains(self: Stack[T],item: T) -> bool

  

   Determines whether an element is in the System.Collections.Generic.Stack.

  

   item: The object to locate in the System.Collections.Generic.Stack. The value can be null for 

    reference types.

  

   Returns: true if item is found in the System.Collections.Generic.Stack; otherwise,false.
  """
  pass
 def CopyTo(self,array,arrayIndex):
  """ CopyTo(self: Stack[T],array: Array[T],arrayIndex: int) """
  pass
 def GetEnumerator(self):
  """
  GetEnumerator(self: Stack[T]) -> Enumerator

  

   Returns an enumerator for the System.Collections.Generic.Stack.

   Returns: An System.Collections.Generic.Stack for the System.Collections.Generic.Stack.
  """
  pass
 def Peek(self):
  """
  Peek(self: Stack[T]) -> T

  

   Returns the object at the top of the System.Collections.Generic.Stack without removing it.

   Returns: The object at the top of the System.Collections.Generic.Stack.
  """
  pass
 def Pop(self):
  """
  Pop(self: Stack[T]) -> T

  

   Removes and returns the object at the top of the System.Collections.Generic.Stack.

   Returns: The object removed from the top of the System.Collections.Generic.Stack.
  """
  pass
 def Push(self,item):
  """
  Push(self: Stack[T],item: T)

   Inserts an object at the top of the System.Collections.Generic.Stack.

  

   item: The object to push onto the System.Collections.Generic.Stack. The value can be null for 

    reference types.
  """
  pass
 def ToArray(self):
  """
  ToArray(self: Stack[T]) -> Array[T]

  

   Copies the System.Collections.Generic.Stack to a new array.

   Returns: A new array containing copies of the elements of the System.Collections.Generic.Stack.
  """
  pass
 def TrimExcess(self):
  """
  TrimExcess(self: Stack[T])

   Sets the capacity to the actual number of elements in the System.Collections.Generic.Stack,if 

    that number is less than 90 percent of current capacity.
  """
  pass
 def __contains__(self,*args):
  """ __contains__[T](enumerable: IEnumerable[T],value: T) -> bool """
  pass
 def __init__(self,*args):
  """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
  pass
 def __iter__(self,*args):
  """ __iter__(self: IEnumerable) -> object """
  pass
 def __len__(self,*args):
  """ x.__len__() <==> len(x) """
  pass
 @staticmethod
 def __new__(self,*__args):
  """
  __new__(cls: type)

  __new__(cls: type,capacity: int)

  __new__(cls: type,collection: IEnumerable[T])
  """
  pass
 def __reduce_ex__(self,*args):
  pass
 def __repr__(self,*args):
  """ __repr__(self: object) -> str """
  pass
 Count=property(lambda self: object(),lambda self,v: None,lambda self: None)
 """Gets the number of elements contained in the System.Collections.Generic.Stack.



Get: Count(self: Stack[T]) -> int



"""


 Enumerator=None


