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


__doc__ = None

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

  _ORIGIN = 'built-in'

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

  def exec_module(self, module):
    """ Exec a built-in module """
    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

__name__ = '_codecs'
__package__ = ''
__spec__ = None

def ascii_decode(data, errors=None):
  pass

def ascii_encode(str, errors=None):
  pass

def charmap_build(map):
  pass

def charmap_decode(data, errors=None, mapping=None):
  pass

def charmap_encode(str, errors=None, mapping=None):
  pass

def decode(obj, encoding='utf-8', errors='strict'):
  """ Decodes obj using the codec registered for encoding.
  
  Default encoding is 'utf-8'.  errors may be given to set a
  different error handling scheme.  Default is 'strict' meaning that encoding
  errors raise a ValueError.  Other possible values are 'ignore', 'replace'
  and 'backslashreplace' as well as any other name registered with
  codecs.register_error that can handle ValueErrors. """
  pass

def encode(obj, encoding='utf-8', errors='strict'):
  """ Encodes obj using the codec registered for encoding.
  
  The default encoding is 'utf-8'.  errors may be given to set a
  different error handling scheme.  Default is 'strict' meaning that encoding
  errors raise a ValueError.  Other possible values are 'ignore', 'replace'
  and 'backslashreplace' as well as any other name registered with
  codecs.register_error that can handle ValueErrors. """
  pass

def escape_decode(data, errors=None):
  pass

def escape_encode(data, errors=None):
  pass

def latin_1_decode(data, errors=None):
  pass

def latin_1_encode(str, errors=None):
  pass

def lookup(encoding):
  """ Looks up a codec tuple in the Python codec registry and returns a CodecInfo object. """
  pass

def lookup_error(name):
  """ lookup_error(errors) -> handler
  
  Return the error handler for the specified error handling name or raise a
  LookupError, if no handler exists under this name. """
  return None

def raw_unicode_escape_decode(data, errors=None, final=True):
  pass

def raw_unicode_escape_encode(str, errors=None):
  pass

def readbuffer_encode(data, errors=None):
  pass

def register(search_function):
  """ Register a codec search function.
  
  Search functions are expected to take one argument, the encoding name in
  all lower case letters, and either return None, or a tuple of functions
  (encoder, decoder, stream_reader, stream_writer) (or a CodecInfo object). """
  pass

def register_error(errors, handler):
  """ Register the specified error handler under the name errors.
  
  handler must be a callable object, that will be called with an exception
  instance containing information about the location of the encoding/decoding
  error and must return a (replacement, new position) tuple. """
  pass

def unicode_escape_decode(data, errors=None, final=True):
  pass

def unicode_escape_encode(str, errors=None):
  pass

def unregister(search_function):
  """ Unregister a codec search function and clear the registry's cache.
  
  If the search function is not registered, do nothing. """
  pass

def utf_16_be_decode(data, errors=None, final=False):
  pass

def utf_16_be_encode(str, errors=None):
  pass

def utf_16_decode(data, errors=None, final=False):
  pass

def utf_16_encode(str, errors=None, byteorder=0):
  pass

def utf_16_ex_decode(data, errors=None, byteorder=0, final=False):
  pass

def utf_16_le_decode(data, errors=None, final=False):
  pass

def utf_16_le_encode(str, errors=None):
  pass

def utf_32_be_decode(data, errors=None, final=False):
  pass

def utf_32_be_encode(str, errors=None):
  pass

def utf_32_decode(data, errors=None, final=False):
  pass

def utf_32_encode(str, errors=None, byteorder=0):
  pass

def utf_32_ex_decode(data, errors=None, byteorder=0, final=False):
  pass

def utf_32_le_decode(data, errors=None, final=False):
  pass

def utf_32_le_encode(str, errors=None):
  pass

def utf_7_decode(data, errors=None, final=False):
  pass

def utf_7_encode(str, errors=None):
  pass

def utf_8_decode(data, errors=None, final=False):
  pass

def utf_8_encode(str, errors=None):
  pass