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

""" Bisection algorithms.

This module provides support for maintaining a list in sorted order without
having to sort the list after each insertion. For long lists of items with
expensive comparison operations, this can be an improvement over the more
common approach.
 """

__doc__ = """Bisection algorithms.

This module provides support for maintaining a list in sorted order without
having to sort the list after each insertion. For long lists of items with
expensive comparison operations, this can be an improvement over the more
common approach.
"""

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__ = '_bisect'
__package__ = ''
__spec__ = None

def bisect():
  """ Alias for bisect_right().
   """
  pass

def bisect_left(a, x, lo=None, hi=None):
  """ bisect_left(a, x[, lo[, hi]]) -> index
  
  Return the index where to insert item x in list a, assuming a is sorted.
  
  The return value i is such that all e in a[:i] have e < x, and all e in
  a[i:] have e >= x.  So if x already appears in the list, i points just
  before the leftmost x already there.
  
  Optional args lo (default 0) and hi (default len(a)) bound the
  slice of a to be searched.
   """
  return None

def bisect_right(a, x, lo=None, hi=None):
  """ bisect_right(a, x[, lo[, hi]]) -> index
  
  Return the index where to insert item x in list a, assuming a is sorted.
  
  The return value i is such that all e in a[:i] have e <= x, and all e in
  a[i:] have e > x.  So if x already appears in the list, i points just
  beyond the rightmost x already there
  
  Optional args lo (default 0) and hi (default len(a)) bound the
  slice of a to be searched.
   """
  return None

def insort():
  """ Alias for insort_right().
   """
  pass

def insort_left(a, x, lo=None, hi=None):
  """ insort_left(a, x[, lo[, hi]])
  
  Insert item x in list a, and keep it sorted assuming a is sorted.
  
  If x is already in a, insert it to the left of the leftmost x.
  
  Optional args lo (default 0) and hi (default len(a)) bound the
  slice of a to be searched.
   """
  pass

def insort_right(a, x, lo=None, hi=None):
  """ insort_right(a, x[, lo[, hi]])
  
  Insert item x in list a, and keep it sorted assuming a is sorted.
  
  If x is already in a, insert it to the right of the rightmost x.
  
  Optional args lo (default 0) and hi (default len(a)) bound the
  slice of a to be searched.
   """
  pass