# coding: utf-8
# AUTO-GENERATED FILE -- DO NOT EDIT

""" High performance data structures.
- deque:        ordered collection accessible from endpoints only
- defaultdict:  dict subclass with a default value factory
 """

class OrderedDict(dict):
  """ Dictionary that remembers insertion order """

  def __init__(self, *args, **kwargs):
    pass

  def clear(self):
    """ od.clear() -> None.  Remove all items from od. """
    return None

  def copy(self):
    """ od.copy() -> a shallow copy of od """
    return None

  def fromkeys(self, iterable, value=None):
    """ Create a new ordered dictionary with keys from iterable and values set to value. """
    pass

  def items(self):
    pass

  def keys(self):
    pass

  def move_to_end(self, key, last=True):
    """ Move an existing element to the end (or beginning if last is false).
    
    Raise KeyError if the element does not exist. """
    pass

  def pop(self, k, d=None):
    """ od.pop(k[,d]) -> v, remove specified key and return the corresponding
            value.  If key is not found, d is returned if given, otherwise KeyError
            is raised.
    
             """
    return None

  def popitem(self, last=True):
    """ Remove and return a (key, value) pair from the dictionary.
    
    Pairs are returned in LIFO order if last is true or FIFO order if false. """
    pass

  def setdefault(self, key, default=None):
    """ Insert key with a value of default if key is not in the dictionary.
    
    Return the value for key if key is in the dictionary, else default. """
    pass

  def update(self):
    pass

  def values(self):
    pass

__doc__ = """High performance data structures.
- deque:        ordered collection accessible from endpoints only
- defaultdict:  dict subclass with a default value factory
"""

class __loader__(object):
  """ Meta path import for built-in modules.
  
      All methods are either class or static methods to avoid the need to
      instantiate the class.
  
       """

  def create_module(self, spec):
    """ Create a built-in module """
    pass

  def exec_module(self, module):
    """ Exec a built-in module """
    pass

  def find_module(self, fullname, path=None):
    """ Find the built-in module.
    
            If 'path' is ever specified then the search is considered a failure.
    
            This method is deprecated.  Use find_spec() instead.
    
             """
    pass

  def find_spec(self, fullname, path=None, target=None):
    pass

  def get_code(self, fullname):
    """ Return None as built-in modules do not have code objects. """
    pass

  def get_source(self, fullname):
    """ Return None as built-in modules do not have source code. """
    pass

  def is_package(self, fullname):
    """ Return False as built-in modules are never packages. """
    pass

  def load_module(self, fullname):
    """ Load the specified module into sys.modules and return it.
    
        This method is deprecated.  Use loader.exec_module instead.
    
         """
    pass

  def module_repr(self, module):
    """ Return repr for the module.
    
            The method is deprecated.  The import machinery does the job itself.
    
             """
    pass

__name__ = '_collections'
__package__ = ''
__spec__ = None

def _count_elements(mapping, iterable):
  """ _count_elements(mapping, iterable) -> None
  
  Count elements in the iterable, updating the mapping """
  return None

class _deque_iterator(object):

  pass

class _deque_reverse_iterator(object):

  pass

class defaultdict(dict):
  """ defaultdict(default_factory[, ...]) --> dict with default factory
  
  The default factory is called without arguments to produce
  a new value when a key is not present, in __getitem__ only.
  A defaultdict compares equal to a dict with the same items.
  All remaining arguments are treated the same as if they were
  passed to the dict constructor, including keyword arguments.
   """

  def __init__(self, default_factory, *args):
    return {}

  def copy(self):
    """ D.copy() -> a shallow copy of D. """
    return None

  default_factory = None

  def fromkeys(self, iterable, value=None):
    """ Create a new dictionary with keys from iterable and values set to value. """
    pass

class deque(object):
  """ deque([iterable[, maxlen]]) --> deque object
  
  A list-like sequence optimized for data accesses near its endpoints. """

  def __init__(self, iterable=None, maxlen=None):
    return None

  def append(self):
    """ Add an element to the right side of the deque. """
    pass

  def appendleft(self):
    """ Add an element to the left side of the deque. """
    pass

  def clear(self):
    """ Remove all elements from the deque. """
    pass

  def copy(self):
    """ Return a shallow copy of a deque. """
    pass

  def count(self, value):
    """ D.count(value) -> integer -- return number of occurrences of value """
    return 1

  def extend(self):
    """ Extend the right side of the deque with elements from the iterable """
    pass

  def extendleft(self):
    """ Extend the left side of the deque with elements from the iterable """
    pass

  def index(self, value, start=None, stop=None):
    """ D.index(value, [start, [stop]]) -> integer -- return first index of value.
    Raises ValueError if the value is not present. """
    return 1

  def insert(self, index, object):
    """ D.insert(index, object) -- insert object before index """
    return None

  maxlen = property(None, None, None,
                    """ maximum size of a deque or None if unbounded """
                    )


  def pop(self):
    """ Remove and return the rightmost element. """
    pass

  def popleft(self):
    """ Remove and return the leftmost element. """
    pass

  def remove(self, value):
    """ D.remove(value) -- remove first occurrence of value. """
    return None

  def reverse(self):
    """ D.reverse() -- reverse *IN PLACE* """
    return None

  def rotate(self):
    """ Rotate the deque n steps to the right (default n=1).  If n is negative, rotates left. """
    pass