# 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
 """

__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 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 a built-in module. """
    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 mappping """
  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, *args, **kwargs):
    return {}

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

  default_factory = None

  def fromkeys(self, iterable, value=None):
    """ Returns a new dict with keys from iterable and values equal to value. """
    pass

class deque(object):
  """ deque([iterable[, maxlen]]) --> deque object
  
  Build an ordered collection with optimized access from its endpoints. """

  def __init__(self, *args, **kwargs):
    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 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

  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