python开发基础(二)运算符以及数据类型之float(浮点类型)
阅读原文时间:2023年07月10日阅读:3

# encoding: utf-8

module builtins

from (built-in)

by generator 1.147

"""
Built-in functions, exceptions, and other objects.

Noteworthy: None is the `nil' object; Ellipsis represents `…' in slices.
"""

no imports

Variables with simple values

definition of False omitted

definition of None omitted

definition of True omitted

definition of __debug__ omitted

functions

def abs(*args, **kwargs): # real signature unknown
""" Return the absolute value of the argument. """
pass

def all(*args, **kwargs): # real signature unknown
"""
Return True if bool(x) is True for all values x in the iterable.

If the iterable is empty, return True.  
"""  
pass

def any(*args, **kwargs): # real signature unknown
"""
Return True if bool(x) is True for any x in the iterable.

If the iterable is empty, return False.  
"""  
pass

def ascii(*args, **kwargs): # real signature unknown
"""
Return an ASCII-only representation of an object.

As repr(), return a string containing a printable representation of an  
object, but escape the non-ASCII characters in the string returned by  
repr() using \\\\x, \\\\u or \\\\U escapes. This generates a string similar  
to that returned by repr() in Python 2.  
"""  
pass

def bin(*args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__
"""
Return the binary representation of an integer.

   >>> bin(2796202)  
   '0b1010101010101010101010'  
"""  
pass

def breakpoint(*args, **kws): # real signature unknown; restored from __doc__
"""
breakpoint(*args, **kws)

Call sys.breakpointhook(\*args, \*\*kws).  sys.breakpointhook() must accept  
whatever arguments are passed.

By default, this drops you into the pdb debugger.  
"""  
pass

def callable(i_e_, some_kind_of_function): # real signature unknown; restored from __doc__
"""
Return whether the object is callable (i.e., some kind of function).

Note that classes are callable, as are instances of classes with a  
\_\_call\_\_() method.  
"""  
pass

def chr(*args, **kwargs): # real signature unknown
""" Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff. """
pass

def compile(*args, **kwargs): # real signature unknown
"""
Compile source into a code object that can be executed by exec() or eval().

The source code may represent a Python module, statement or expression.  
The filename will be used for run-time error messages.  
The mode must be 'exec' to compile a module, 'single' to compile a  
single (interactive) statement, or 'eval' to compile an expression.  
The flags argument, if present, controls which future statements influence  
the compilation of the code.  
The dont\_inherit argument, if true, stops the compilation inheriting  
the effects of any future statements in effect in the code calling  
compile; if absent or false these statements do influence the compilation,  
in addition to any features explicitly specified.  
"""  
pass

def copyright(*args, **kwargs): # real signature unknown
"""
interactive prompt objects for printing the license text, a list of
contributors and the copyright notice.
"""
pass

def credits(*args, **kwargs): # real signature unknown
"""
interactive prompt objects for printing the license text, a list of
contributors and the copyright notice.
"""
pass

def delattr(x, y): # real signature unknown; restored from __doc__
"""
Deletes the named attribute from the given object.

delattr(x, 'y') is equivalent to \`\`del x.y''  
"""  
pass

def dir(p_object=None): # real signature unknown; restored from __doc__
"""
dir([object]) -> list of strings

If called without an argument, return the names in the current scope.  
Else, return an alphabetized list of names comprising (some of) the attributes  
of the given object, and of attributes reachable from it.  
If the object supplies a method named \_\_dir\_\_, it will be used; otherwise  
the default dir() logic is used and returns:  
  for a module object: the module's attributes.  
  for a class object:  its attributes, and recursively the attributes  
    of its bases.  
  for any other object: its attributes, its class's attributes, and  
    recursively the attributes of its class's base classes.  
"""  
return \[\]

def divmod(x, y): # known case of builtins.divmod
""" Return the tuple (x//y, x%y). Invariant: div*y + mod == x. """
return (0, 0)

def eval(*args, **kwargs): # real signature unknown
"""
Evaluate the given source in the context of globals and locals.

The source may be a string representing a Python expression  
or a code object as returned by compile().  
The globals must be a dictionary and locals can be any mapping,  
defaulting to the current globals and locals.  
If only globals is given, locals defaults to it.  
"""  
pass

def exec(*args, **kwargs): # real signature unknown
"""
Execute the given source in the context of globals and locals.

The source may be a string representing one or more Python statements  
or a code object as returned by compile().  
The globals must be a dictionary and locals can be any mapping,  
defaulting to the current globals and locals.  
If only globals is given, locals defaults to it.  
"""  
pass

def exit(*args, **kwargs): # real signature unknown
pass

def format(*args, **kwargs): # real signature unknown
"""
Return value.__format__(format_spec)

format\_spec defaults to the empty string.  
See the Format Specification Mini-Language section of help('FORMATTING') for  
details.  
"""  
pass

def getattr(object, name, default=None): # known special case of getattr
"""
getattr(object, name[, default]) -> value

Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.  
When a default argument is given, it is returned when the attribute doesn't  
exist; without it, an exception is raised in that case.  
"""  
pass

def globals(*args, **kwargs): # real signature unknown
"""
Return the dictionary containing the current scope's global variables.

NOTE: Updates to this dictionary \*will\* affect name lookups in the current  
global scope and vice-versa.  
"""  
pass

def hasattr(*args, **kwargs): # real signature unknown
"""
Return whether the object has an attribute with the given name.

This is done by calling getattr(obj, name) and catching AttributeError.  
"""  
pass

def hash(*args, **kwargs): # real signature unknown
"""
Return the hash value for the given object.

Two objects that compare equal must also have the same hash value, but the  
reverse is not necessarily true.  
"""  
pass

def help(): # real signature unknown; restored from __doc__
"""
Define the builtin 'help'.

    This is a wrapper around pydoc.help that provides a helpful message  
    when 'help' is typed at the Python interactive prompt.

    Calling help() at the Python prompt starts an interactive help session.  
    Calling help(thing) prints help for the python object 'thing'.  
"""  
pass

def hex(*args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__
"""
Return the hexadecimal representation of an integer.

   >>> hex(12648430)  
   '0xc0ffee'  
"""  
pass

def id(*args, **kwargs): # real signature unknown
"""
Return the identity of an object.

This is guaranteed to be unique among simultaneously existing objects.  
(CPython uses the object's memory address.)  
"""  
pass

def input(*args, **kwargs): # real signature unknown
"""
Read a string from standard input. The trailing newline is stripped.

The prompt string, if given, is printed to standard output without a  
trailing newline before reading input.

If the user hits EOF (\*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.  
On \*nix systems, readline is used if available.  
"""  
pass

def isinstance(x, A_tuple): # real signature unknown; restored from __doc__
"""
Return whether an object is an instance of a class or of a subclass thereof.

A tuple, as in \`\`isinstance(x, (A, B, ...))\`\`, may be given as the target to  
check against. This is equivalent to \`\`isinstance(x, A) or isinstance(x, B)  
or ...\`\` etc.  
"""  
pass

def issubclass(x, A_tuple): # real signature unknown; restored from __doc__
"""
Return whether 'cls' is a derived from another class or is the same class.

A tuple, as in \`\`issubclass(x, (A, B, ...))\`\`, may be given as the target to  
check against. This is equivalent to \`\`issubclass(x, A) or issubclass(x, B)  
or ...\`\` etc.  
"""  
pass

def iter(source, sentinel=None): # known special case of iter
"""
iter(iterable) -> iterator
iter(callable, sentinel) -> iterator

Get an iterator from an object.  In the first form, the argument must  
supply its own iterator, or be a sequence.  
In the second form, the callable is called until it returns the sentinel.  
"""  
pass

def len(*args, **kwargs): # real signature unknown
""" Return the number of items in a container. """
pass

def license(*args, **kwargs): # real signature unknown
"""
interactive prompt objects for printing the license text, a list of
contributors and the copyright notice.
"""
pass

def locals(*args, **kwargs): # real signature unknown
"""
Return a dictionary containing the current scope's local variables.

NOTE: Whether or not updates to this dictionary will affect name lookups in  
the local scope and vice-versa is \*implementation dependent\* and not  
covered by any backwards compatibility guarantees.  
"""  
pass

def max(*args, key=None): # known special case of max
"""
max(iterable, *[, default=obj, key=func]) -> value
max(arg1, arg2, *args, *[, key=func]) -> value

With a single iterable argument, return its biggest item. The  
default keyword-only argument specifies an object to return if  
the provided iterable is empty.  
With two or more arguments, return the largest argument.  
"""  
pass

def min(*args, key=None): # known special case of min
"""
min(iterable, *[, default=obj, key=func]) -> value
min(arg1, arg2, *args, *[, key=func]) -> value

With a single iterable argument, return its smallest item. The  
default keyword-only argument specifies an object to return if  
the provided iterable is empty.  
With two or more arguments, return the smallest argument.  
"""  
pass

def next(iterator, default=None): # real signature unknown; restored from __doc__
"""
next(iterator[, default])

Return the next item from the iterator. If default is given and the iterator  
is exhausted, it is returned instead of raising StopIteration.  
"""  
pass

def oct(*args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__
"""
Return the octal representation of an integer.

   >>> oct(342391)  
   '0o1234567'  
"""  
pass

def open(file, mode='r', buffering=None, encoding=None, errors=None, newline=None, closefd=True): # known special case of open
"""
Open file and return a stream. Raise OSError upon failure.

file is either a text or byte string giving the name (and the path  
if the file isn't in the current working directory) of the file to  
be opened or an integer file descriptor of the file to be  
wrapped. (If a file descriptor is given, it is closed when the  
returned I/O object is closed, unless closefd is set to False.)

mode is an optional string that specifies the mode in which the file  
is opened. It defaults to 'r' which means open for reading in text  
mode.  Other common values are 'w' for writing (truncating the file if  
it already exists), 'x' for creating and writing to a new file, and  
'a' for appending (which on some Unix systems, means that all writes  
append to the end of the file regardless of the current seek position).  
In text mode, if encoding is not specified the encoding used is platform  
dependent: locale.getpreferredencoding(False) is called to get the  
current locale encoding. (For reading and writing raw bytes use binary  
mode and leave encoding unspecified.) The available modes are:

========= ===============================================================  
Character Meaning  
--------- ---------------------------------------------------------------  
'r'       open for reading (default)  
'w'       open for writing, truncating the file first  
'x'       create a new file and open it for writing  
'a'       open for writing, appending to the end of the file if it exists  
'b'       binary mode  
't'       text mode (default)  
'+'       open a disk file for updating (reading and writing)  
'U'       universal newline mode (deprecated)  
========= ===============================================================

The default mode is 'rt' (open for reading text). For binary random  
access, the mode 'w+b' opens and truncates the file to 0 bytes, while  
'r+b' opens the file without truncation. The 'x' mode implies 'w' and  
raises an \`FileExistsError\` if the file already exists.

Python distinguishes between files opened in binary and text modes,  
even when the underlying operating system doesn't. Files opened in  
binary mode (appending 'b' to the mode argument) return contents as  
bytes objects without any decoding. In text mode (the default, or when  
't' is appended to the mode argument), the contents of the file are  
returned as strings, the bytes having been first decoded using a  
platform-dependent encoding or using the specified encoding if given.

'U' mode is deprecated and will raise an exception in future versions  
of Python.  It has no effect in Python 3.  Use newline to control  
universal newlines mode.

buffering is an optional integer used to set the buffering policy.  
Pass 0 to switch buffering off (only allowed in binary mode), 1 to select  
line buffering (only usable in text mode), and an integer > 1 to indicate  
the size of a fixed-size chunk buffer.  When no buffering argument is  
given, the default buffering policy works as follows:

\* Binary files are buffered in fixed-size chunks; the size of the buffer  
  is chosen using a heuristic trying to determine the underlying device's  
  "block size" and falling back on \`io.DEFAULT\_BUFFER\_SIZE\`.  
  On many systems, the buffer will typically be 4096 or 8192 bytes long.

\* "Interactive" text files (files for which isatty() returns True)  
  use line buffering.  Other text files use the policy described above  
  for binary files.

encoding is the name of the encoding used to decode or encode the  
file. This should only be used in text mode. The default encoding is  
platform dependent, but any encoding supported by Python can be  
passed.  See the codecs module for the list of supported encodings.

errors is an optional string that specifies how encoding errors are to  
be handled---this argument should not be used in binary mode. Pass  
'strict' to raise a ValueError exception if there is an encoding error  
(the default of None has the same effect), or pass 'ignore' to ignore  
errors. (Note that ignoring encoding errors can lead to data loss.)  
See the documentation for codecs.register or run 'help(codecs.Codec)'  
for a list of the permitted encoding error strings.

newline controls how universal newlines works (it only applies to text  
mode). It can be None, '', '\\n', '\\r', and '\\r\\n'.  It works as  
follows:

\* On input, if newline is None, universal newlines mode is  
  enabled. Lines in the input can end in '\\n', '\\r', or '\\r\\n', and  
  these are translated into '\\n' before being returned to the  
  caller. If it is '', universal newline mode is enabled, but line  
  endings are returned to the caller untranslated. If it has any of  
  the other legal values, input lines are only terminated by the given  
  string, and the line ending is returned to the caller untranslated.

\* On output, if newline is None, any '\\n' characters written are  
  translated to the system default line separator, os.linesep. If  
  newline is '' or '\\n', no translation takes place. If newline is any  
  of the other legal values, any '\\n' characters written are translated  
  to the given string.

If closefd is False, the underlying file descriptor will be kept open  
when the file is closed. This does not work when a file name is given  
and must be True in that case.

A custom opener can be used by passing a callable as \*opener\*. The  
underlying file descriptor for the file object is then obtained by  
calling \*opener\* with (\*file\*, \*flags\*). \*opener\* must return an open  
file descriptor (passing os.open as \*opener\* results in functionality  
similar to passing None).

open() returns a file object whose type depends on the mode, and  
through which the standard file operations such as reading and writing  
are performed. When open() is used to open a file in a text mode ('w',  
'r', 'wt', 'rt', etc.), it returns a TextIOWrapper. When used to open  
a file in a binary mode, the returned class varies: in read binary  
mode, it returns a BufferedReader; in write binary and append binary  
modes, it returns a BufferedWriter, and in read/write mode, it returns  
a BufferedRandom.

It is also possible to use a string or bytearray as a file for both  
reading and writing. For strings StringIO can be used like a file  
opened in a text mode, and for bytes a BytesIO can be used like a file  
opened in a binary mode.  
"""  
pass

def ord(*args, **kwargs): # real signature unknown
""" Return the Unicode code point for a one-character string. """
pass

def pow(*args, **kwargs): # real signature unknown
"""
Equivalent to x**y (with two arguments) or x**y % z (with three arguments)

Some types, such as ints, are able to use a more efficient algorithm when  
invoked using the three argument form.  
"""  
pass

def print(self, *args, sep=' ', end='\n', file=None): # known special case of print
"""
print(value, …, sep=' ', end='\n', file=sys.stdout, flush=False)

Prints the values to a stream, or to sys.stdout by default.  
Optional keyword arguments:  
file:  a file-like object (stream); defaults to the current sys.stdout.  
sep:   string inserted between values, default a space.  
end:   string appended after the last value, default a newline.  
flush: whether to forcibly flush the stream.  
"""  
pass

def quit(*args, **kwargs): # real signature unknown
pass

def repr(obj): # real signature unknown; restored from __doc__
"""
Return the canonical string representation of the object.

For many object types, including most builtins, eval(repr(obj)) == obj.  
"""  
pass

def round(*args, **kwargs): # real signature unknown
"""
Round a number to a given precision in decimal digits.

The return value is an integer if ndigits is omitted or None.  Otherwise  
the return value has the same type as the number.  ndigits may be negative.  
"""  
pass

def setattr(x, y, v): # real signature unknown; restored from __doc__
"""
Sets the named attribute on the given object to the specified value.

setattr(x, 'y', v) is equivalent to \`\`x.y = v''  
"""  
pass

def sorted(*args, **kwargs): # real signature unknown
"""
Return a new list containing all items from the iterable in ascending order.

A custom key function can be supplied to customize the sort order, and the  
reverse flag can be set to request the result in descending order.  
"""  
pass

def sum(*args, **kwargs): # real signature unknown
"""
Return the sum of a 'start' value (default: 0) plus an iterable of numbers

When the iterable is empty, return the start value.  
This function is intended specifically for use with numeric values and may  
reject non-numeric types.  
"""  
pass

def vars(p_object=None): # real signature unknown; restored from __doc__
"""
vars([object]) -> dictionary

Without arguments, equivalent to locals().  
With an argument, equivalent to object.\_\_dict\_\_.  
"""  
return {}

def __build_class__(func, name, *bases, metaclass=None, **kwds): # real signature unknown; restored from __doc__
"""
__build_class__(func, name, *bases, metaclass=None, **kwds) -> class

Internal helper function used by the class statement.  
"""  
pass

def __import__(name, globals=None, locals=None, fromlist=(), level=0): # real signature unknown; restored from __doc__
"""
__import__(name, globals=None, locals=None, fromlist=(), level=0) -> module

Import a module. Because this function is meant for use by the Python  
interpreter and not for general use, it is better to use  
importlib.import\_module() to programmatically import a module.

The globals argument is only used to determine the context;  
they are not modified.  The locals argument is unused.  The fromlist  
should be a list of names to emulate \`\`from name import ...'', or an  
empty list to emulate \`\`import name''.  
When importing a module from a package, note that \_\_import\_\_('A.B', ...)  
returns package A when fromlist is empty, but its submodule B when  
fromlist is not empty.  The level argument is used to determine whether to  
perform absolute or relative imports: 0 is absolute, while a positive number  
is the number of parent directories to search relative to the current module.  
"""  
pass

classes

class __generator(object):
'''A mock class representing the generator function type.'''
def __init__(self):
self.gi_code = None
self.gi_frame = None
self.gi_running = 0

def \_\_iter\_\_(self):  
    '''Defined to support iteration over container.'''  
    pass

def \_\_next\_\_(self):  
    '''Return the next item from the container.'''  
    pass

def close(self):  
    '''Raises new GeneratorExit exception inside the generator to terminate the iteration.'''  
    pass

def send(self, value):  
    '''Resumes the generator and "sends" a value that becomes the result of the current yield-expression.'''  
    pass

def throw(self, type, value=None, traceback=None):  
    '''Used to raise an exception inside the generator.'''  
    pass

class __asyncgenerator(object):
'''A mock class representing the async generator function type.'''
def __init__(self):
'''Create an async generator object.'''
self.__name__ = ''
self.__qualname__ = ''
self.ag_await = None
self.ag_frame = None
self.ag_running = False
self.ag_code = None

def \_\_aiter\_\_(self):  
    '''Defined to support iteration over container.'''  
    pass

def \_\_anext\_\_(self):  
    '''Returns an awaitable, that performs one asynchronous generator iteration when awaited.'''  
    pass

def aclose(self):  
    '''Returns an awaitable, that throws a GeneratorExit exception into generator.'''  
    pass

def asend(self, value):  
    '''Returns an awaitable, that pushes the value object in generator.'''  
    pass

def athrow(self, type, value=None, traceback=None):  
    '''Returns an awaitable, that throws an exception into generator.'''  
    pass

class __function(object):
'''A mock class representing function type.'''

def \_\_init\_\_(self):  
    self.\_\_name\_\_ = ''  
    self.\_\_doc\_\_ = ''  
    self.\_\_dict\_\_ = ''  
    self.\_\_module\_\_ = ''

    self.\_\_defaults\_\_ = {}  
    self.\_\_globals\_\_ = {}  
    self.\_\_closure\_\_ = None  
    self.\_\_code\_\_ = None  
    self.\_\_name\_\_ = ''

    self.\_\_annotations\_\_ = {}  
    self.\_\_kwdefaults\_\_ = {}

    self.\_\_qualname\_\_ = ''

class __method(object):
'''A mock class representing method type.'''

def \_\_init\_\_(self):

    self.\_\_func\_\_ = None  
    self.\_\_self\_\_ = None

class __coroutine(object):
'''A mock class representing coroutine type.'''

def \_\_init\_\_(self):  
    self.\_\_name\_\_ = ''  
    self.\_\_qualname\_\_ = ''  
    self.cr\_await = None  
    self.cr\_frame = None  
    self.cr\_running = False  
    self.cr\_code = None

def \_\_await\_\_(self):  
    return \[\]

def close(self):  
    pass

def send(self, value):  
    pass

def throw(self, type, value=None, traceback=None):  
    pass

class __namedtuple(tuple):
'''A mock base class for named tuples.'''

\_\_slots\_\_ = ()  
\_fields = ()

def \_\_new\_\_(cls, \*args, \*\*kwargs):  
    'Create a new instance of the named tuple.'  
    return tuple.\_\_new\_\_(cls, \*args)

@classmethod  
def \_make(cls, iterable, new=tuple.\_\_new\_\_, len=len):  
    'Make a new named tuple object from a sequence or iterable.'  
    return new(cls, iterable)

def \_\_repr\_\_(self):  
    return ''

def \_asdict(self):  
    'Return a new dict which maps field types to their values.'  
    return {}

def \_replace(self, \*\*kwargs):  
    'Return a new named tuple object replacing specified fields with new values.'  
    return self

def \_\_getnewargs\_\_(self):  
    return tuple(self)

class object:
""" The most base type """
def __delattr__(self, *args, **kwargs): # real signature unknown
""" Implement delattr(self, name). """
pass

def \_\_dir\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Default dir() implementation. """  
    pass

def \_\_eq\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self==value. """  
    pass

def \_\_format\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Default object formatter. """  
    pass

def \_\_getattribute\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return getattr(self, name). """  
    pass

def \_\_ge\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self>=value. """  
    pass

def \_\_gt\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self>value. """  
    pass

def \_\_hash\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return hash(self). """  
    pass

def \_\_init\_subclass\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    This method is called when a class is subclassed.

    The default implementation does nothing. It may be  
    overridden to extend subclasses.  
    """  
    pass

def \_\_init\_\_(self): # known special case of object.\_\_init\_\_  
    """ Initialize self.  See help(type(self)) for accurate signature. """  
    pass

def \_\_le\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self<=value. """  
    pass

def \_\_lt\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self<value. """  
    pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(cls, \*more): # known special case of object.\_\_new\_\_  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

def \_\_ne\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self!=value. """  
    pass

def \_\_reduce\_ex\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Helper for pickle. """  
    pass

def \_\_reduce\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Helper for pickle. """  
    pass

def \_\_repr\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return repr(self). """  
    pass

def \_\_setattr\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Implement setattr(self, name, value). """  
    pass

def \_\_sizeof\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Size of object in memory, in bytes. """  
    pass

def \_\_str\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return str(self). """  
    pass

@classmethod # known case  
def \_\_subclasshook\_\_(cls, subclass): # known special case of object.\_\_subclasshook\_\_  
    """  
    Abstract classes can override this to customize issubclass().

    This is invoked early on by abc.ABCMeta.\_\_subclasscheck\_\_().  
    It should return True, False or NotImplemented.  If it returns  
    NotImplemented, the normal algorithm is used.  Otherwise, it  
    overrides the normal algorithm (and the outcome is cached).  
    """  
    pass

\_\_class\_\_ = None # (!) forward: type, real value is "<class 'type'>"  
\_\_dict\_\_ = {}  
\_\_doc\_\_ = ''  
\_\_module\_\_ = ''

class BaseException(object):
""" Common base class for all exceptions """
def with_traceback(self, tb): # real signature unknown; restored from __doc__
"""
Exception.with_traceback(tb) --
set self.__traceback__ to tb and return self.
"""
pass

def \_\_delattr\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Implement delattr(self, name). """  
    pass

def \_\_getattribute\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return getattr(self, name). """  
    pass

def \_\_init\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

def \_\_reduce\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    pass

def \_\_repr\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return repr(self). """  
    pass

def \_\_setattr\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Implement setattr(self, name, value). """  
    pass

def \_\_setstate\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    pass

def \_\_str\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return str(self). """  
    pass

args = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

\_\_cause\_\_ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""exception cause"""

\_\_context\_\_ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""exception context"""

\_\_suppress\_context\_\_ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

\_\_traceback\_\_ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

\_\_dict\_\_ = None # (!) real value is "mappingproxy({'\_\_repr\_\_': <slot wrapper '\_\_repr\_\_' of 'BaseException' objects>, '\_\_str\_\_': <slot wrapper '\_\_str\_\_' of 'BaseException' objects>, '\_\_getattribute\_\_': <slot wrapper '\_\_getattribute\_\_' of 'BaseException' objects>, '\_\_setattr\_\_': <slot wrapper '\_\_setattr\_\_' of 'BaseException' objects>, '\_\_delattr\_\_': <slot wrapper '\_\_delattr\_\_' of 'BaseException' objects>, '\_\_init\_\_': <slot wrapper '\_\_init\_\_' of 'BaseException' objects>, '\_\_new\_\_': <built-in method \_\_new\_\_ of type object at 0x00007FFC49400810>, '\_\_reduce\_\_': <method '\_\_reduce\_\_' of 'BaseException' objects>, '\_\_setstate\_\_': <method '\_\_setstate\_\_' of 'BaseException' objects>, 'with\_traceback': <method 'with\_traceback' of 'BaseException' objects>, '\_\_suppress\_context\_\_': <member '\_\_suppress\_context\_\_' of 'BaseException' objects>, '\_\_dict\_\_': <attribute '\_\_dict\_\_' of 'BaseException' objects>, 'args': <attribute 'args' of 'BaseException' objects>, '\_\_traceback\_\_': <attribute '\_\_traceback\_\_' of 'BaseException' objects>, '\_\_context\_\_': <attribute '\_\_context\_\_' of 'BaseException' objects>, '\_\_cause\_\_': <attribute '\_\_cause\_\_' of 'BaseException' objects>, '\_\_doc\_\_': 'Common base class for all exceptions'})"

class Exception(BaseException):
""" Common base class for all non-exit exceptions. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

class ArithmeticError(Exception):
""" Base class for arithmetic errors. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

class AssertionError(Exception):
""" Assertion failed. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

class AttributeError(Exception):
""" Attribute not found. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

class WindowsError(Exception):
""" Base class for I/O related errors. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

def \_\_reduce\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    pass

def \_\_str\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return str(self). """  
    pass

characters\_written = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

errno = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""POSIX exception code"""

filename = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""exception filename"""

filename2 = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""second exception filename"""

strerror = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""exception strerror"""

winerror = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""Win32 exception code"""

OSError = WindowsError

IOError = WindowsError

EnvironmentError = WindowsError

class BlockingIOError(OSError):
""" I/O operation would block. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

class int(object):
"""
int([x]) -> integer
int(x, base=10) -> integer

Convert a number or string to an integer, or return 0 if no arguments  
are given.  If x is a number, return x.\_\_int\_\_().  For floating point  
numbers, this truncates towards zero.

If x is not a number or if base is given, then x must be a string,  
bytes, or bytearray instance representing an integer literal in the  
given base.  The literal can be preceded by '+' or '-' and be surrounded  
by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.  
Base 0 means to interpret the base from the string as an integer literal.  
>>> int('0b100', base=0)  
4  
"""  
def bit\_length(self): # real signature unknown; restored from \_\_doc\_\_  
    """  
    Number of bits necessary to represent self in binary.

    >>> bin(37)  
    '0b100101'  
    >>> (37).bit\_length()  
    6  
    """  
    pass

def conjugate(self, \*args, \*\*kwargs): # real signature unknown  
    """ Returns self, the complex conjugate of any int. """  
    pass

@classmethod # known case  
def from\_bytes(cls, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return the integer represented by the given array of bytes.

      bytes  
        Holds the array of bytes to convert.  The argument must either  
        support the buffer protocol or be an iterable object producing bytes.  
        Bytes and bytearray are examples of built-in objects that support the  
        buffer protocol.  
      byteorder  
        The byte order used to represent the integer.  If byteorder is 'big',  
        the most significant byte is at the beginning of the byte array.  If  
        byteorder is 'little', the most significant byte is at the end of the  
        byte array.  To request the native byte order of the host system, use  
        \`sys.byteorder' as the byte order value.  
      signed  
        Indicates whether two's complement is used to represent the integer.  
    """  
    pass

def to\_bytes(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return an array of bytes representing an integer.

      length  
        Length of bytes object to use.  An OverflowError is raised if the  
        integer is not representable with the given number of bytes.  
      byteorder  
        The byte order used to represent the integer.  If byteorder is 'big',  
        the most significant byte is at the beginning of the byte array.  If  
        byteorder is 'little', the most significant byte is at the end of the  
        byte array.  To request the native byte order of the host system, use  
        \`sys.byteorder' as the byte order value.  
      signed  
        Determines whether two's complement is used to represent the integer.  
        If signed is False and a negative integer is given, an OverflowError  
        is raised.  
    """  
    pass

def \_\_abs\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ abs(self) """  
    pass

def \_\_add\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self+value. """  
    pass

def \_\_and\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self&value. """  
    pass

def \_\_bool\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ self != 0 """  
    pass

def \_\_ceil\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Ceiling of an Integral returns itself. """  
    pass

def \_\_divmod\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return divmod(self, value). """  
    pass

def \_\_eq\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self==value. """  
    pass

def \_\_float\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ float(self) """  
    pass

def \_\_floordiv\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self//value. """  
    pass

def \_\_floor\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Flooring an Integral returns itself. """  
    pass

def \_\_format\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    pass

def \_\_getattribute\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return getattr(self, name). """  
    pass

def \_\_getnewargs\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    pass

def \_\_ge\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self>=value. """  
    pass

def \_\_gt\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self>value. """  
    pass

def \_\_hash\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return hash(self). """  
    pass

def \_\_index\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self converted to an integer, if self is suitable for use as an index into a list. """  
    pass

def \_\_init\_\_(self, x, base=10): # known special case of int.\_\_init\_\_  
    """  
    int(\[x\]) -> integer  
    int(x, base=10) -> integer

    Convert a number or string to an integer, or return 0 if no arguments  
    are given.  If x is a number, return x.\_\_int\_\_().  For floating point  
    numbers, this truncates towards zero.

    If x is not a number or if base is given, then x must be a string,  
    bytes, or bytearray instance representing an integer literal in the  
    given base.  The literal can be preceded by '+' or '-' and be surrounded  
    by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.  
    Base 0 means to interpret the base from the string as an integer literal.  
    >>> int('0b100', base=0)  
    4  
    # (copied from class doc)  
    """  
    pass

def \_\_int\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ int(self) """  
    pass

def \_\_invert\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ ~self """  
    pass

def \_\_le\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self<=value. """  
    pass

def \_\_lshift\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self<<value. """  
    pass

def \_\_lt\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self<value. """  
    pass

def \_\_mod\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self%value. """  
    pass

def \_\_mul\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self\*value. """  
    pass

def \_\_neg\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ -self """  
    pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

def \_\_ne\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self!=value. """  
    pass

def \_\_or\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self|value. """  
    pass

def \_\_pos\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ +self """  
    pass

def \_\_pow\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return pow(self, value, mod). """  
    pass

def \_\_radd\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return value+self. """  
    pass

def \_\_rand\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return value&self. """  
    pass

def \_\_rdivmod\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return divmod(value, self). """  
    pass

def \_\_repr\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return repr(self). """  
    pass

def \_\_rfloordiv\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return value//self. """  
    pass

def \_\_rlshift\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return value<<self. """  
    pass

def \_\_rmod\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return value%self. """  
    pass

def \_\_rmul\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return value\*self. """  
    pass

def \_\_ror\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return value|self. """  
    pass

def \_\_round\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Rounding an Integral returns itself.  
    Rounding with an ndigits argument also returns an integer.  
    """  
    pass

def \_\_rpow\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return pow(value, self, mod). """  
    pass

def \_\_rrshift\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return value>>self. """  
    pass

def \_\_rshift\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self>>value. """  
    pass

def \_\_rsub\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return value-self. """  
    pass

def \_\_rtruediv\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return value/self. """  
    pass

def \_\_rxor\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return value^self. """  
    pass

def \_\_sizeof\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Returns size in memory, in bytes. """  
    pass

def \_\_str\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return str(self). """  
    pass

def \_\_sub\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self-value. """  
    pass

def \_\_truediv\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self/value. """  
    pass

def \_\_trunc\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Truncating an Integral returns itself. """  
    pass

def \_\_xor\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self^value. """  
    pass

denominator = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""the denominator of a rational number in lowest terms"""

imag = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""the imaginary part of a complex number"""

numerator = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""the numerator of a rational number in lowest terms"""

real = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""the real part of a complex number"""

class bool(int):
"""
bool(x) -> bool

Returns True when the argument x is true, False otherwise.  
The builtins True and False are the only two instances of the class bool.  
The class bool is a subclass of the class int, and cannot be subclassed.  
"""  
def \_\_and\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self&value. """  
    pass

def \_\_init\_\_(self, x): # real signature unknown; restored from \_\_doc\_\_  
    pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

def \_\_or\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self|value. """  
    pass

def \_\_rand\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return value&self. """  
    pass

def \_\_repr\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return repr(self). """  
    pass

def \_\_ror\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return value|self. """  
    pass

def \_\_rxor\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return value^self. """  
    pass

def \_\_str\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return str(self). """  
    pass

def \_\_xor\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self^value. """  
    pass

class ConnectionError(OSError):
""" Connection error. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

class BrokenPipeError(ConnectionError):
""" Broken pipe. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

class BufferError(Exception):
""" Buffer error. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

class bytearray(object):
"""
bytearray(iterable_of_ints) -> bytearray
bytearray(string, encoding[, errors]) -> bytearray
bytearray(bytes_or_buffer) -> mutable copy of bytes_or_buffer
bytearray(int) -> bytes array of size given by the parameter initialized with null bytes
bytearray() -> empty bytes array

Construct a mutable bytearray object from:  
  - an iterable yielding integers in range(256)  
  - a text string encoded using the specified encoding  
  - a bytes or a buffer object  
  - any object implementing the buffer API.  
  - an integer  
"""  
def append(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Append a single item to the end of the bytearray.

      item  
        The item to be appended.  
    """  
    pass

def capitalize(self): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.capitalize() -> copy of B

    Return a copy of B with only its first character capitalized (ASCII)  
    and the rest lower-cased.  
    """  
    pass

def center(self, width, fillchar=None): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.center(width\[, fillchar\]) -> copy of B

    Return B centered in a string of length width.  Padding is  
    done using the specified fill character (default is a space).  
    """  
    pass

def clear(self, \*args, \*\*kwargs): # real signature unknown  
    """ Remove all items from the bytearray. """  
    pass

def copy(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return a copy of B. """  
    pass

def count(self, sub, start=None, end=None): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.count(sub\[, start\[, end\]\]) -> int

    Return the number of non-overlapping occurrences of subsection sub in  
    bytes B\[start:end\].  Optional arguments start and end are interpreted  
    as in slice notation.  
    """  
    return 0

def decode(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Decode the bytearray using the codec registered for encoding.

      encoding  
        The encoding with which to decode the bytearray.  
      errors  
        The error handling scheme to use for the handling of decoding errors.  
        The default is 'strict' meaning that decoding errors raise a  
        UnicodeDecodeError. Other possible values are 'ignore' and 'replace'  
        as well as any other name registered with codecs.register\_error that  
        can handle UnicodeDecodeErrors.  
    """  
    pass

def endswith(self, suffix, start=None, end=None): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.endswith(suffix\[, start\[, end\]\]) -> bool

    Return True if B ends with the specified suffix, False otherwise.  
    With optional start, test B beginning at that position.  
    With optional end, stop comparing B at that position.  
    suffix can also be a tuple of bytes to try.  
    """  
    return False

def expandtabs(self, tabsize=8): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.expandtabs(tabsize=8) -> copy of B

    Return a copy of B where all tab characters are expanded using spaces.  
    If tabsize is not given, a tab size of 8 characters is assumed.  
    """  
    pass

def extend(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Append all the items from the iterator or sequence to the end of the bytearray.

      iterable\_of\_ints  
        The iterable of items to append.  
    """  
    pass

def find(self, sub, start=None, end=None): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.find(sub\[, start\[, end\]\]) -> int

    Return the lowest index in B where subsection sub is found,  
    such that sub is contained within B\[start,end\].  Optional  
    arguments start and end are interpreted as in slice notation.

    Return -1 on failure.  
    """  
    return 0

@classmethod # known case  
def fromhex(cls, \*args, \*\*kwargs): # real signature unknown; NOTE: unreliably restored from \_\_doc\_\_  
    """  
    Create a bytearray object from a string of hexadecimal numbers.

    Spaces between two numbers are accepted.  
    Example: bytearray.fromhex('B9 01EF') -> bytearray(b'\\\\xb9\\\\x01\\\\xef')  
    """  
    pass

def hex(self): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.hex() -> string

    Create a string of hexadecimal numbers from a bytearray object.  
    Example: bytearray(\[0xb9, 0x01, 0xef\]).hex() -> 'b901ef'.  
    """  
    return ""

def index(self, sub, start=None, end=None): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.index(sub\[, start\[, end\]\]) -> int

    Return the lowest index in B where subsection sub is found,  
    such that sub is contained within B\[start,end\].  Optional  
    arguments start and end are interpreted as in slice notation.

    Raises ValueError when the subsection is not found.  
    """  
    return 0

def insert(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Insert a single item into the bytearray before the given index.

      index  
        The index where the value is to be inserted.  
      item  
        The item to be inserted.  
    """  
    pass

def isalnum(self): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.isalnum() -> bool

    Return True if all characters in B are alphanumeric  
    and there is at least one character in B, False otherwise.  
    """  
    return False

def isalpha(self): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.isalpha() -> bool

    Return True if all characters in B are alphabetic  
    and there is at least one character in B, False otherwise.  
    """  
    return False

def isascii(self): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.isascii() -> bool

    Return True if B is empty or all characters in B are ASCII,  
    False otherwise.  
    """  
    return False

def isdigit(self): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.isdigit() -> bool

    Return True if all characters in B are digits  
    and there is at least one character in B, False otherwise.  
    """  
    return False

def islower(self): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.islower() -> bool

    Return True if all cased characters in B are lowercase and there is  
    at least one cased character in B, False otherwise.  
    """  
    return False

def isspace(self): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.isspace() -> bool

    Return True if all characters in B are whitespace  
    and there is at least one character in B, False otherwise.  
    """  
    return False

def istitle(self): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.istitle() -> bool

    Return True if B is a titlecased string and there is at least one  
    character in B, i.e. uppercase characters may only follow uncased  
    characters and lowercase characters only cased ones. Return False  
    otherwise.  
    """  
    return False

def isupper(self): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.isupper() -> bool

    Return True if all cased characters in B are uppercase and there is  
    at least one cased character in B, False otherwise.  
    """  
    return False

def join(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Concatenate any number of bytes/bytearray objects.

    The bytearray whose method is called is inserted in between each pair.

    The result is returned as a new bytearray object.  
    """  
    pass

def ljust(self, width, fillchar=None): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.ljust(width\[, fillchar\]) -> copy of B

    Return B left justified in a string of length width. Padding is  
    done using the specified fill character (default is a space).  
    """  
    pass

def lower(self): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.lower() -> copy of B

    Return a copy of B with all ASCII characters converted to lowercase.  
    """  
    pass

def lstrip(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Strip leading bytes contained in the argument.

    If the argument is omitted or None, strip leading ASCII whitespace.  
    """  
    pass

@staticmethod # known case  
def maketrans(\*args, \*\*kwargs): # real signature unknown  
    """  
    Return a translation table useable for the bytes or bytearray translate method.

    The returned table will be one where each byte in frm is mapped to the byte at  
    the same position in to.

    The bytes objects frm and to must be of the same length.  
    """  
    pass

def partition(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Partition the bytearray into three parts using the given separator.

    This will search for the separator sep in the bytearray. If the separator is  
    found, returns a 3-tuple containing the part before the separator, the  
    separator itself, and the part after it as new bytearray objects.

    If the separator is not found, returns a 3-tuple containing the copy of the  
    original bytearray object and two empty bytearray objects.  
    """  
    pass

def pop(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Remove and return a single item from B.

      index  
        The index from where to remove the item.  
        -1 (the default value) means remove the last item.

    If no index argument is given, will pop the last item.  
    """  
    pass

def remove(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Remove the first occurrence of a value in the bytearray.

      value  
        The value to remove.  
    """  
    pass

def replace(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return a copy with all occurrences of substring old replaced by new.

      count  
        Maximum number of occurrences to replace.  
        -1 (the default value) means replace all occurrences.

    If the optional argument count is given, only the first count occurrences are  
    replaced.  
    """  
    pass

def reverse(self, \*args, \*\*kwargs): # real signature unknown  
    """ Reverse the order of the values in B in place. """  
    pass

def rfind(self, sub, start=None, end=None): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.rfind(sub\[, start\[, end\]\]) -> int

    Return the highest index in B where subsection sub is found,  
    such that sub is contained within B\[start,end\].  Optional  
    arguments start and end are interpreted as in slice notation.

    Return -1 on failure.  
    """  
    return 0

def rindex(self, sub, start=None, end=None): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.rindex(sub\[, start\[, end\]\]) -> int

    Return the highest index in B where subsection sub is found,  
    such that sub is contained within B\[start,end\].  Optional  
    arguments start and end are interpreted as in slice notation.

    Raise ValueError when the subsection is not found.  
    """  
    return 0

def rjust(self, width, fillchar=None): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.rjust(width\[, fillchar\]) -> copy of B

    Return B right justified in a string of length width. Padding is  
    done using the specified fill character (default is a space)  
    """  
    pass

def rpartition(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Partition the bytearray into three parts using the given separator.

    This will search for the separator sep in the bytearray, starting at the end.  
    If the separator is found, returns a 3-tuple containing the part before the  
    separator, the separator itself, and the part after it as new bytearray  
    objects.

    If the separator is not found, returns a 3-tuple containing two empty bytearray  
    objects and the copy of the original bytearray object.  
    """  
    pass

def rsplit(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return a list of the sections in the bytearray, using sep as the delimiter.

      sep  
        The delimiter according which to split the bytearray.  
        None (the default value) means split on ASCII whitespace characters  
        (space, tab, return, newline, formfeed, vertical tab).  
      maxsplit  
        Maximum number of splits to do.  
        -1 (the default value) means no limit.

    Splitting is done starting at the end of the bytearray and working to the front.  
    """  
    pass

def rstrip(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Strip trailing bytes contained in the argument.

    If the argument is omitted or None, strip trailing ASCII whitespace.  
    """  
    pass

def split(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return a list of the sections in the bytearray, using sep as the delimiter.

      sep  
        The delimiter according which to split the bytearray.  
        None (the default value) means split on ASCII whitespace characters  
        (space, tab, return, newline, formfeed, vertical tab).  
      maxsplit  
        Maximum number of splits to do.  
        -1 (the default value) means no limit.  
    """  
    pass

def splitlines(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return a list of the lines in the bytearray, breaking at line boundaries.

    Line breaks are not included in the resulting list unless keepends is given and  
    true.  
    """  
    pass

def startswith(self, prefix, start=None, end=None): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.startswith(prefix\[, start\[, end\]\]) -> bool

    Return True if B starts with the specified prefix, False otherwise.  
    With optional start, test B beginning at that position.  
    With optional end, stop comparing B at that position.  
    prefix can also be a tuple of bytes to try.  
    """  
    return False

def strip(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Strip leading and trailing bytes contained in the argument.

    If the argument is omitted or None, strip leading and trailing ASCII whitespace.  
    """  
    pass

def swapcase(self): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.swapcase() -> copy of B

    Return a copy of B with uppercase ASCII characters converted  
    to lowercase ASCII and vice versa.  
    """  
    pass

def title(self): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.title() -> copy of B

    Return a titlecased version of B, i.e. ASCII words start with uppercase  
    characters, all remaining cased characters have lowercase.  
    """  
    pass

def translate(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return a copy with each character mapped by the given translation table.

      table  
        Translation table, which must be a bytes object of length 256.

    All characters occurring in the optional argument delete are removed.  
    The remaining characters are mapped through the given translation table.  
    """  
    pass

def upper(self): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.upper() -> copy of B

    Return a copy of B with all ASCII characters converted to uppercase.  
    """  
    pass

def zfill(self, width): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.zfill(width) -> copy of B

    Pad a numeric string B with zeros on the left, to fill a field  
    of the specified width.  B is never truncated.  
    """  
    pass

def \_\_add\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self+value. """  
    pass

def \_\_alloc\_\_(self): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.\_\_alloc\_\_() -> int

    Return the number of bytes actually allocated.  
    """  
    return 0

def \_\_contains\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return key in self. """  
    pass

def \_\_delitem\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Delete self\[key\]. """  
    pass

def \_\_eq\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self==value. """  
    pass

def \_\_getattribute\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return getattr(self, name). """  
    pass

def \_\_getitem\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self\[key\]. """  
    pass

def \_\_ge\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self>=value. """  
    pass

def \_\_gt\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self>value. """  
    pass

def \_\_iadd\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Implement self+=value. """  
    pass

def \_\_imul\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Implement self\*=value. """  
    pass

def \_\_init\_\_(self, source=None, encoding=None, errors='strict'): # known special case of bytearray.\_\_init\_\_  
    """  
    bytearray(iterable\_of\_ints) -> bytearray  
    bytearray(string, encoding\[, errors\]) -> bytearray  
    bytearray(bytes\_or\_buffer) -> mutable copy of bytes\_or\_buffer  
    bytearray(int) -> bytes array of size given by the parameter initialized with null bytes  
    bytearray() -> empty bytes array

    Construct a mutable bytearray object from:  
      - an iterable yielding integers in range(256)  
      - a text string encoded using the specified encoding  
      - a bytes or a buffer object  
      - any object implementing the buffer API.  
      - an integer  
    # (copied from class doc)  
    """  
    pass

def \_\_iter\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Implement iter(self). """  
    pass

def \_\_len\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return len(self). """  
    pass

def \_\_le\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self<=value. """  
    pass

def \_\_lt\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self<value. """  
    pass

def \_\_mod\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self%value. """  
    pass

def \_\_mul\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self\*value. """  
    pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

def \_\_ne\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self!=value. """  
    pass

def \_\_reduce\_ex\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return state information for pickling. """  
    pass

def \_\_reduce\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return state information for pickling. """  
    pass

def \_\_repr\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return repr(self). """  
    pass

def \_\_rmod\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return value%self. """  
    pass

def \_\_rmul\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return value\*self. """  
    pass

def \_\_setitem\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Set self\[key\] to value. """  
    pass

def \_\_sizeof\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Returns the size of the bytearray object in memory, in bytes. """  
    pass

def \_\_str\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return str(self). """  
    pass

\_\_hash\_\_ = None

class bytes(object):
"""
bytes(iterable_of_ints) -> bytes
bytes(string, encoding[, errors]) -> bytes
bytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer
bytes(int) -> bytes object of size given by the parameter initialized with null bytes
bytes() -> empty bytes object

Construct an immutable array of bytes from:  
  - an iterable yielding integers in range(256)  
  - a text string encoded using the specified encoding  
  - any object implementing the buffer API.  
  - an integer  
"""  
def capitalize(self): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.capitalize() -> copy of B

    Return a copy of B with only its first character capitalized (ASCII)  
    and the rest lower-cased.  
    """  
    pass

def center(self, width, fillchar=None): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.center(width\[, fillchar\]) -> copy of B

    Return B centered in a string of length width.  Padding is  
    done using the specified fill character (default is a space).  
    """  
    pass

def count(self, sub, start=None, end=None): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.count(sub\[, start\[, end\]\]) -> int

    Return the number of non-overlapping occurrences of subsection sub in  
    bytes B\[start:end\].  Optional arguments start and end are interpreted  
    as in slice notation.  
    """  
    return 0

def decode(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Decode the bytes using the codec registered for encoding.

      encoding  
        The encoding with which to decode the bytes.  
      errors  
        The error handling scheme to use for the handling of decoding errors.  
        The default is 'strict' meaning that decoding errors raise a  
        UnicodeDecodeError. Other possible values are 'ignore' and 'replace'  
        as well as any other name registered with codecs.register\_error that  
        can handle UnicodeDecodeErrors.  
    """  
    pass

def endswith(self, suffix, start=None, end=None): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.endswith(suffix\[, start\[, end\]\]) -> bool

    Return True if B ends with the specified suffix, False otherwise.  
    With optional start, test B beginning at that position.  
    With optional end, stop comparing B at that position.  
    suffix can also be a tuple of bytes to try.  
    """  
    return False

def expandtabs(self, tabsize=8): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.expandtabs(tabsize=8) -> copy of B

    Return a copy of B where all tab characters are expanded using spaces.  
    If tabsize is not given, a tab size of 8 characters is assumed.  
    """  
    pass

def find(self, sub, start=None, end=None): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.find(sub\[, start\[, end\]\]) -> int

    Return the lowest index in B where subsection sub is found,  
    such that sub is contained within B\[start,end\].  Optional  
    arguments start and end are interpreted as in slice notation.

    Return -1 on failure.  
    """  
    return 0

@classmethod # known case  
def fromhex(cls, \*args, \*\*kwargs): # real signature unknown; NOTE: unreliably restored from \_\_doc\_\_  
    """  
    Create a bytes object from a string of hexadecimal numbers.

    Spaces between two numbers are accepted.  
    Example: bytes.fromhex('B9 01EF') -> b'\\\\xb9\\\\x01\\\\xef'.  
    """  
    pass

def hex(self): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.hex() -> string

    Create a string of hexadecimal numbers from a bytes object.  
    Example: b'\\xb9\\x01\\xef'.hex() -> 'b901ef'.  
    """  
    return ""

def index(self, sub, start=None, end=None): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.index(sub\[, start\[, end\]\]) -> int

    Return the lowest index in B where subsection sub is found,  
    such that sub is contained within B\[start,end\].  Optional  
    arguments start and end are interpreted as in slice notation.

    Raises ValueError when the subsection is not found.  
    """  
    return 0

def isalnum(self): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.isalnum() -> bool

    Return True if all characters in B are alphanumeric  
    and there is at least one character in B, False otherwise.  
    """  
    return False

def isalpha(self): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.isalpha() -> bool

    Return True if all characters in B are alphabetic  
    and there is at least one character in B, False otherwise.  
    """  
    return False

def isascii(self): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.isascii() -> bool

    Return True if B is empty or all characters in B are ASCII,  
    False otherwise.  
    """  
    return False

def isdigit(self): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.isdigit() -> bool

    Return True if all characters in B are digits  
    and there is at least one character in B, False otherwise.  
    """  
    return False

def islower(self): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.islower() -> bool

    Return True if all cased characters in B are lowercase and there is  
    at least one cased character in B, False otherwise.  
    """  
    return False

def isspace(self): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.isspace() -> bool

    Return True if all characters in B are whitespace  
    and there is at least one character in B, False otherwise.  
    """  
    return False

def istitle(self): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.istitle() -> bool

    Return True if B is a titlecased string and there is at least one  
    character in B, i.e. uppercase characters may only follow uncased  
    characters and lowercase characters only cased ones. Return False  
    otherwise.  
    """  
    return False

def isupper(self): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.isupper() -> bool

    Return True if all cased characters in B are uppercase and there is  
    at least one cased character in B, False otherwise.  
    """  
    return False

def join(self, \*args, \*\*kwargs): # real signature unknown; NOTE: unreliably restored from \_\_doc\_\_  
    """  
    Concatenate any number of bytes objects.

    The bytes whose method is called is inserted in between each pair.

    The result is returned as a new bytes object.

    Example: b'.'.join(\[b'ab', b'pq', b'rs'\]) -> b'ab.pq.rs'.  
    """  
    pass

def ljust(self, width, fillchar=None): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.ljust(width\[, fillchar\]) -> copy of B

    Return B left justified in a string of length width. Padding is  
    done using the specified fill character (default is a space).  
    """  
    pass

def lower(self): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.lower() -> copy of B

    Return a copy of B with all ASCII characters converted to lowercase.  
    """  
    pass

def lstrip(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Strip leading bytes contained in the argument.

    If the argument is omitted or None, strip leading  ASCII whitespace.  
    """  
    pass

@staticmethod # known case  
def maketrans(\*args, \*\*kwargs): # real signature unknown  
    """  
    Return a translation table useable for the bytes or bytearray translate method.

    The returned table will be one where each byte in frm is mapped to the byte at  
    the same position in to.

    The bytes objects frm and to must be of the same length.  
    """  
    pass

def partition(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Partition the bytes into three parts using the given separator.

    This will search for the separator sep in the bytes. If the separator is found,  
    returns a 3-tuple containing the part before the separator, the separator  
    itself, and the part after it.

    If the separator is not found, returns a 3-tuple containing the original bytes  
    object and two empty bytes objects.  
    """  
    pass

def replace(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return a copy with all occurrences of substring old replaced by new.

      count  
        Maximum number of occurrences to replace.  
        -1 (the default value) means replace all occurrences.

    If the optional argument count is given, only the first count occurrences are  
    replaced.  
    """  
    pass

def rfind(self, sub, start=None, end=None): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.rfind(sub\[, start\[, end\]\]) -> int

    Return the highest index in B where subsection sub is found,  
    such that sub is contained within B\[start,end\].  Optional  
    arguments start and end are interpreted as in slice notation.

    Return -1 on failure.  
    """  
    return 0

def rindex(self, sub, start=None, end=None): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.rindex(sub\[, start\[, end\]\]) -> int

    Return the highest index in B where subsection sub is found,  
    such that sub is contained within B\[start,end\].  Optional  
    arguments start and end are interpreted as in slice notation.

    Raise ValueError when the subsection is not found.  
    """  
    return 0

def rjust(self, width, fillchar=None): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.rjust(width\[, fillchar\]) -> copy of B

    Return B right justified in a string of length width. Padding is  
    done using the specified fill character (default is a space)  
    """  
    pass

def rpartition(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Partition the bytes into three parts using the given separator.

    This will search for the separator sep in the bytes, starting at the end. If  
    the separator is found, returns a 3-tuple containing the part before the  
    separator, the separator itself, and the part after it.

    If the separator is not found, returns a 3-tuple containing two empty bytes  
    objects and the original bytes object.  
    """  
    pass

def rsplit(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return a list of the sections in the bytes, using sep as the delimiter.

      sep  
        The delimiter according which to split the bytes.  
        None (the default value) means split on ASCII whitespace characters  
        (space, tab, return, newline, formfeed, vertical tab).  
      maxsplit  
        Maximum number of splits to do.  
        -1 (the default value) means no limit.

    Splitting is done starting at the end of the bytes and working to the front.  
    """  
    pass

def rstrip(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Strip trailing bytes contained in the argument.

    If the argument is omitted or None, strip trailing ASCII whitespace.  
    """  
    pass

def split(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return a list of the sections in the bytes, using sep as the delimiter.

      sep  
        The delimiter according which to split the bytes.  
        None (the default value) means split on ASCII whitespace characters  
        (space, tab, return, newline, formfeed, vertical tab).  
      maxsplit  
        Maximum number of splits to do.  
        -1 (the default value) means no limit.  
    """  
    pass

def splitlines(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return a list of the lines in the bytes, breaking at line boundaries.

    Line breaks are not included in the resulting list unless keepends is given and  
    true.  
    """  
    pass

def startswith(self, prefix, start=None, end=None): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.startswith(prefix\[, start\[, end\]\]) -> bool

    Return True if B starts with the specified prefix, False otherwise.  
    With optional start, test B beginning at that position.  
    With optional end, stop comparing B at that position.  
    prefix can also be a tuple of bytes to try.  
    """  
    return False

def strip(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Strip leading and trailing bytes contained in the argument.

    If the argument is omitted or None, strip leading and trailing ASCII whitespace.  
    """  
    pass

def swapcase(self): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.swapcase() -> copy of B

    Return a copy of B with uppercase ASCII characters converted  
    to lowercase ASCII and vice versa.  
    """  
    pass

def title(self): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.title() -> copy of B

    Return a titlecased version of B, i.e. ASCII words start with uppercase  
    characters, all remaining cased characters have lowercase.  
    """  
    pass

def translate(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return a copy with each character mapped by the given translation table.

      table  
        Translation table, which must be a bytes object of length 256.

    All characters occurring in the optional argument delete are removed.  
    The remaining characters are mapped through the given translation table.  
    """  
    pass

def upper(self): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.upper() -> copy of B

    Return a copy of B with all ASCII characters converted to uppercase.  
    """  
    pass

def zfill(self, width): # real signature unknown; restored from \_\_doc\_\_  
    """  
    B.zfill(width) -> copy of B

    Pad a numeric string B with zeros on the left, to fill a field  
    of the specified width.  B is never truncated.  
    """  
    pass

def \_\_add\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self+value. """  
    pass

def \_\_contains\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return key in self. """  
    pass

def \_\_eq\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self==value. """  
    pass

def \_\_getattribute\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return getattr(self, name). """  
    pass

def \_\_getitem\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self\[key\]. """  
    pass

def \_\_getnewargs\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    pass

def \_\_ge\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self>=value. """  
    pass

def \_\_gt\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self>value. """  
    pass

def \_\_hash\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return hash(self). """  
    pass

def \_\_init\_\_(self, value=b'', encoding=None, errors='strict'): # known special case of bytes.\_\_init\_\_  
    """  
    bytes(iterable\_of\_ints) -> bytes  
    bytes(string, encoding\[, errors\]) -> bytes  
    bytes(bytes\_or\_buffer) -> immutable copy of bytes\_or\_buffer  
    bytes(int) -> bytes object of size given by the parameter initialized with null bytes  
    bytes() -> empty bytes object

    Construct an immutable array of bytes from:  
      - an iterable yielding integers in range(256)  
      - a text string encoded using the specified encoding  
      - any object implementing the buffer API.  
      - an integer  
    # (copied from class doc)  
    """  
    pass

def \_\_iter\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Implement iter(self). """  
    pass

def \_\_len\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return len(self). """  
    pass

def \_\_le\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self<=value. """  
    pass

def \_\_lt\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self<value. """  
    pass

def \_\_mod\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self%value. """  
    pass

def \_\_mul\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self\*value. """  
    pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

def \_\_ne\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self!=value. """  
    pass

def \_\_repr\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return repr(self). """  
    pass

def \_\_rmod\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return value%self. """  
    pass

def \_\_rmul\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return value\*self. """  
    pass

def \_\_str\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return str(self). """  
    pass

class Warning(Exception):
""" Base class for warning categories. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

class BytesWarning(Warning):
"""
Base class for warnings about bytes and buffer related problems, mostly
related to conversion from str or comparing to str.
"""
def __init__(self, *args, **kwargs): # real signature unknown
pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

class ChildProcessError(OSError):
""" Child process error. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

class classmethod(object):
"""
classmethod(function) -> method

Convert a function to be a class method.

A class method receives the class as implicit first argument,  
just like an instance method receives the instance.  
To declare a class method, use this idiom:

  class C:  
      @classmethod  
      def f(cls, arg1, arg2, ...):  
          ...

It can be called either on the class (e.g. C.f()) or on an instance  
(e.g. C().f()).  The instance is ignored except for its class.  
If a class method is called for a derived class, the derived class  
object is passed as the implied first argument.

Class methods are different than C++ or Java static methods.  
If you want those, see the staticmethod builtin.  
"""  
def \_\_get\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return an attribute of instance, which is of type owner. """  
    pass

def \_\_init\_\_(self, function): # real signature unknown; restored from \_\_doc\_\_  
    pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

\_\_func\_\_ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

\_\_isabstractmethod\_\_ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

\_\_dict\_\_ = None # (!) real value is "mappingproxy({'\_\_get\_\_': <slot wrapper '\_\_get\_\_' of 'classmethod' objects>, '\_\_init\_\_': <slot wrapper '\_\_init\_\_' of 'classmethod' objects>, '\_\_new\_\_': <built-in method \_\_new\_\_ of type object at 0x00007FFC49402F20>, '\_\_func\_\_': <member '\_\_func\_\_' of 'classmethod' objects>, '\_\_isabstractmethod\_\_': <attribute '\_\_isabstractmethod\_\_' of 'classmethod' objects>, '\_\_dict\_\_': <attribute '\_\_dict\_\_' of 'classmethod' objects>, '\_\_doc\_\_': 'classmethod(function) -> method\\\\n\\\\nConvert a function to be a class method.\\\\n\\\\nA class method receives the class as implicit first argument,\\\\njust like an instance method receives the instance.\\\\nTo declare a class method, use this idiom:\\\\n\\\\n  class C:\\\\n      @classmethod\\\\n      def f(cls, arg1, arg2, ...):\\\\n          ...\\\\n\\\\nIt can be called either on the class (e.g. C.f()) or on an instance\\\\n(e.g. C().f()).  The instance is ignored except for its class.\\\\nIf a class method is called for a derived class, the derived class\\\\nobject is passed as the implied first argument.\\\\n\\\\nClass methods are different than C++ or Java static methods.\\\\nIf you want those, see the staticmethod builtin.'})"

class complex(object):
"""
Create a complex number from a real part and an optional imaginary part.

This is equivalent to (real + imag\*1j) where imag defaults to 0.  
"""  
def conjugate(self): # real signature unknown; restored from \_\_doc\_\_  
    """  
    complex.conjugate() -> complex

    Return the complex conjugate of its argument. (3-4j).conjugate() == 3+4j.  
    """  
    return complex

def \_\_abs\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ abs(self) """  
    pass

def \_\_add\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self+value. """  
    pass

def \_\_bool\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ self != 0 """  
    pass

def \_\_divmod\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return divmod(self, value). """  
    pass

def \_\_eq\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self==value. """  
    pass

def \_\_float\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ float(self) """  
    pass

def \_\_floordiv\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self//value. """  
    pass

def \_\_format\_\_(self): # real signature unknown; restored from \_\_doc\_\_  
    """  
    complex.\_\_format\_\_() -> str

    Convert to a string according to format\_spec.  
    """  
    return ""

def \_\_getattribute\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return getattr(self, name). """  
    pass

def \_\_getnewargs\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    pass

def \_\_ge\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self>=value. """  
    pass

def \_\_gt\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self>value. """  
    pass

def \_\_hash\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return hash(self). """  
    pass

def \_\_init\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    pass

def \_\_int\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ int(self) """  
    pass

def \_\_le\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self<=value. """  
    pass

def \_\_lt\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self<value. """  
    pass

def \_\_mod\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self%value. """  
    pass

def \_\_mul\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self\*value. """  
    pass

def \_\_neg\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ -self """  
    pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

def \_\_ne\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self!=value. """  
    pass

def \_\_pos\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ +self """  
    pass

def \_\_pow\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return pow(self, value, mod). """  
    pass

def \_\_radd\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return value+self. """  
    pass

def \_\_rdivmod\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return divmod(value, self). """  
    pass

def \_\_repr\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return repr(self). """  
    pass

def \_\_rfloordiv\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return value//self. """  
    pass

def \_\_rmod\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return value%self. """  
    pass

def \_\_rmul\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return value\*self. """  
    pass

def \_\_rpow\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return pow(value, self, mod). """  
    pass

def \_\_rsub\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return value-self. """  
    pass

def \_\_rtruediv\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return value/self. """  
    pass

def \_\_str\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return str(self). """  
    pass

def \_\_sub\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self-value. """  
    pass

def \_\_truediv\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self/value. """  
    pass

imag = property(lambda self: 0.0)  
"""the imaginary part of a complex number

:type: float  
"""

real = property(lambda self: 0.0)  
"""the real part of a complex number

:type: float  
"""

class ConnectionAbortedError(ConnectionError):
""" Connection aborted. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

class ConnectionRefusedError(ConnectionError):
""" Connection refused. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

class ConnectionResetError(ConnectionError):
""" Connection reset. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

class DeprecationWarning(Warning):
""" Base class for warnings about deprecated features. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

class dict(object):
"""
dict() -> new empty dictionary
dict(mapping) -> new dictionary initialized from a mapping object's
(key, value) pairs
dict(iterable) -> new dictionary initialized as if via:
d = {}
for k, v in iterable:
d[k] = v
dict(**kwargs) -> new dictionary initialized with the name=value pairs
in the keyword argument list. For example: dict(one=1, two=2)
"""
def clear(self): # real signature unknown; restored from __doc__
""" D.clear() -> None. Remove all items from D. """
pass

def copy(self): # real signature unknown; restored from \_\_doc\_\_  
    """ D.copy() -> a shallow copy of D """  
    pass

@staticmethod # known case  
def fromkeys(\*args, \*\*kwargs): # real signature unknown  
    """ Create a new dictionary with keys from iterable and values set to value. """  
    pass

def get(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return the value for key if key is in the dictionary, else default. """  
    pass

def items(self): # real signature unknown; restored from \_\_doc\_\_  
    """ D.items() -> a set-like object providing a view on D's items """  
    pass

def keys(self): # real signature unknown; restored from \_\_doc\_\_  
    """ D.keys() -> a set-like object providing a view on D's keys """  
    pass

def pop(self, k, d=None): # real signature unknown; restored from \_\_doc\_\_  
    """  
    D.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  
    """  
    pass

def popitem(self): # real signature unknown; restored from \_\_doc\_\_  
    """  
    D.popitem() -> (k, v), remove and return some (key, value) pair as a  
    2-tuple; but raise KeyError if D is empty.  
    """  
    pass

def setdefault(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    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, E=None, \*\*F): # known special case of dict.update  
    """  
    D.update(\[E, \]\*\*F) -> None.  Update D from dict/iterable E and F.  
    If E is present and has a .keys() method, then does:  for k in E: D\[k\] = E\[k\]  
    If E is present and lacks a .keys() method, then does:  for k, v in E: D\[k\] = v  
    In either case, this is followed by: for k in F:  D\[k\] = F\[k\]  
    """  
    pass

def values(self): # real signature unknown; restored from \_\_doc\_\_  
    """ D.values() -> an object providing a view on D's values """  
    pass

def \_\_contains\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ True if the dictionary has the specified key, else False. """  
    pass

def \_\_delitem\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Delete self\[key\]. """  
    pass

def \_\_eq\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self==value. """  
    pass

def \_\_getattribute\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return getattr(self, name). """  
    pass

def \_\_getitem\_\_(self, y): # real signature unknown; restored from \_\_doc\_\_  
    """ x.\_\_getitem\_\_(y) <==> x\[y\] """  
    pass

def \_\_ge\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self>=value. """  
    pass

def \_\_gt\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self>value. """  
    pass

def \_\_init\_\_(self, seq=None, \*\*kwargs): # known special case of dict.\_\_init\_\_  
    """  
    dict() -> new empty dictionary  
    dict(mapping) -> new dictionary initialized from a mapping object's  
        (key, value) pairs  
    dict(iterable) -> new dictionary initialized as if via:  
        d = {}  
        for k, v in iterable:  
            d\[k\] = v  
    dict(\*\*kwargs) -> new dictionary initialized with the name=value pairs  
        in the keyword argument list.  For example:  dict(one=1, two=2)  
    # (copied from class doc)  
    """  
    pass

def \_\_iter\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Implement iter(self). """  
    pass

def \_\_len\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return len(self). """  
    pass

def \_\_le\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self<=value. """  
    pass

def \_\_lt\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self<value. """  
    pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

def \_\_ne\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self!=value. """  
    pass

def \_\_repr\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return repr(self). """  
    pass

def \_\_setitem\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Set self\[key\] to value. """  
    pass

def \_\_sizeof\_\_(self): # real signature unknown; restored from \_\_doc\_\_  
    """ D.\_\_sizeof\_\_() -> size of D in memory, in bytes """  
    pass

\_\_hash\_\_ = None

class enumerate(object):
"""
Return an enumerate object.

  iterable  
    an object supporting iteration

The enumerate object yields pairs containing a count (from start, which  
defaults to zero) and a value yielded by the iterable argument.

enumerate is useful for obtaining an indexed list:  
    (0, seq\[0\]), (1, seq\[1\]), (2, seq\[2\]), ...  
"""  
def \_\_getattribute\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return getattr(self, name). """  
    pass

def \_\_init\_\_(self, iterable, start=0): # known special case of enumerate.\_\_init\_\_  
    """ Initialize self.  See help(type(self)) for accurate signature. """  
    pass

def \_\_iter\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Implement iter(self). """  
    pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

def \_\_next\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Implement next(self). """  
    pass

def \_\_reduce\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return state information for pickling. """  
    pass

class EOFError(Exception):
""" Read beyond end of file. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

class FileExistsError(OSError):
""" File already exists. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

class FileNotFoundError(OSError):
""" File not found. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

class filter(object):
"""
filter(function or None, iterable) --> filter object

Return an iterator yielding those items of iterable for which function(item)  
is true. If function is None, return the items that are true.  
"""  
def \_\_getattribute\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return getattr(self, name). """  
    pass

def \_\_init\_\_(self, function\_or\_None, iterable): # real signature unknown; restored from \_\_doc\_\_  
    pass

def \_\_iter\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Implement iter(self). """  
    pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

def \_\_next\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Implement next(self). """  
    pass

def \_\_reduce\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return state information for pickling. """  
    pass

class float(object):
""" Convert a string or number to a floating point number, if possible. """
def as_integer_ratio(self): # real signature unknown; restored from __doc__
"""
Return integer ratio.

    Return a pair of integers, whose ratio is exactly equal to the original float  
    and with a positive denominator.

    Raise OverflowError on infinities and a ValueError on NaNs.

    >>> (10.0).as\_integer\_ratio()  
    (10, 1)  
    >>> (0.0).as\_integer\_ratio()  
    (0, 1)  
    >>> (-.25).as\_integer\_ratio()  
    (-1, 4)  
    """  
    pass

def conjugate(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self, the complex conjugate of any float. """  
    pass

@staticmethod # known case  
def fromhex(\*args, \*\*kwargs): # real signature unknown; NOTE: unreliably restored from \_\_doc\_\_  
    """  
    Create a floating-point number from a hexadecimal string.

    >>> float.fromhex('0x1.ffffp10')  
    2047.984375  
    >>> float.fromhex('-0x1p-1074')  
    -5e-324  
    """  
    pass

def hex(self): # real signature unknown; restored from \_\_doc\_\_  
    """  
    Return a hexadecimal representation of a floating-point number.

    >>> (-0.1).hex()  
    '-0x1.999999999999ap-4'  
    >>> 3.14159.hex()  
    '0x1.921f9f01b866ep+1'  
    """  
    pass

def is\_integer(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return True if the float is an integer. """  
    pass

def \_\_abs\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ abs(self) """  
    pass

def \_\_add\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self+value. """  
    pass

def \_\_bool\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ self != 0 """  
    pass

def \_\_divmod\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return divmod(self, value). """  
    pass

def \_\_eq\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self==value. """  
    pass

def \_\_float\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ float(self) """  
    pass

def \_\_floordiv\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self//value. """  
    pass

def \_\_format\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Formats the float according to format\_spec. """  
    pass

def \_\_getattribute\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return getattr(self, name). """  
    pass

def \_\_getformat\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    You probably don't want to use this function.

      typestr  
        Must be 'double' or 'float'.

    It exists mainly to be used in Python's test suite.

    This function returns whichever of 'unknown', 'IEEE, big-endian' or 'IEEE,  
    little-endian' best describes the format of floating point numbers used by the  
    C type named by typestr.  
    """  
    pass

def \_\_getnewargs\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    pass

def \_\_ge\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self>=value. """  
    pass

def \_\_gt\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self>value. """  
    pass

def \_\_hash\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return hash(self). """  
    pass

def \_\_init\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    pass

def \_\_int\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ int(self) """  
    pass

def \_\_le\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self<=value. """  
    pass

def \_\_lt\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self<value. """  
    pass

def \_\_mod\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self%value. """  
    pass

def \_\_mul\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self\*value. """  
    pass

def \_\_neg\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ -self """  
    pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

def \_\_ne\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self!=value. """  
    pass

def \_\_pos\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ +self """  
    pass

def \_\_pow\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return pow(self, value, mod). """  
    pass

def \_\_radd\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return value+self. """  
    pass

def \_\_rdivmod\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return divmod(value, self). """  
    pass

def \_\_repr\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return repr(self). """  
    pass

def \_\_rfloordiv\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return value//self. """  
    pass

def \_\_rmod\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return value%self. """  
    pass

def \_\_rmul\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return value\*self. """  
    pass

def \_\_round\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return the Integral closest to x, rounding half toward even.

    When an argument is passed, work like built-in round(x, ndigits).  
    """  
    pass

def \_\_rpow\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return pow(value, self, mod). """  
    pass

def \_\_rsub\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return value-self. """  
    pass

def \_\_rtruediv\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return value/self. """  
    pass

def \_\_set\_format\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    You probably don't want to use this function.

      typestr  
        Must be 'double' or 'float'.  
      fmt  
        Must be one of 'unknown', 'IEEE, big-endian' or 'IEEE, little-endian',  
        and in addition can only be one of the latter two if it appears to  
        match the underlying C reality.

    It exists mainly to be used in Python's test suite.

    Override the automatic determination of C-level floating point type.  
    This affects how floats are converted to and from binary strings.  
    """  
    pass

def \_\_str\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return str(self). """  
    pass

def \_\_sub\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self-value. """  
    pass

def \_\_truediv\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self/value. """  
    pass

def \_\_trunc\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return the Integral closest to x between 0 and x. """  
    pass

imag = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""the imaginary part of a complex number"""

real = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""the real part of a complex number"""

class FloatingPointError(ArithmeticError):
""" Floating point operation failed. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

class frozenset(object):
"""
frozenset() -> empty frozenset object
frozenset(iterable) -> frozenset object

Build an immutable unordered collection of unique elements.  
"""  
def copy(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return a shallow copy of a set. """  
    pass

def difference(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return the difference of two or more sets as a new set.

    (i.e. all elements that are in this set but not the others.)  
    """  
    pass

def intersection(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return the intersection of two sets as a new set.

    (i.e. all elements that are in both sets.)  
    """  
    pass

def isdisjoint(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return True if two sets have a null intersection. """  
    pass

def issubset(self, \*args, \*\*kwargs): # real signature unknown  
    """ Report whether another set contains this set. """  
    pass

def issuperset(self, \*args, \*\*kwargs): # real signature unknown  
    """ Report whether this set contains another set. """  
    pass

def symmetric\_difference(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return the symmetric difference of two sets as a new set.

    (i.e. all elements that are in exactly one of the sets.)  
    """  
    pass

def union(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return the union of sets as a new set.

    (i.e. all elements that are in either set.)  
    """  
    pass

def \_\_and\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self&value. """  
    pass

def \_\_contains\_\_(self, y): # real signature unknown; restored from \_\_doc\_\_  
    """ x.\_\_contains\_\_(y) <==> y in x. """  
    pass

def \_\_eq\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self==value. """  
    pass

def \_\_getattribute\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return getattr(self, name). """  
    pass

def \_\_ge\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self>=value. """  
    pass

def \_\_gt\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self>value. """  
    pass

def \_\_hash\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return hash(self). """  
    pass

def \_\_init\_\_(self, seq=()): # known special case of frozenset.\_\_init\_\_  
    """ Initialize self.  See help(type(self)) for accurate signature. """  
    pass

def \_\_iter\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Implement iter(self). """  
    pass

def \_\_len\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return len(self). """  
    pass

def \_\_le\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self<=value. """  
    pass

def \_\_lt\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self<value. """  
    pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

def \_\_ne\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self!=value. """  
    pass

def \_\_or\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self|value. """  
    pass

def \_\_rand\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return value&self. """  
    pass

def \_\_reduce\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return state information for pickling. """  
    pass

def \_\_repr\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return repr(self). """  
    pass

def \_\_ror\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return value|self. """  
    pass

def \_\_rsub\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return value-self. """  
    pass

def \_\_rxor\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return value^self. """  
    pass

def \_\_sizeof\_\_(self): # real signature unknown; restored from \_\_doc\_\_  
    """ S.\_\_sizeof\_\_() -> size of S in memory, in bytes """  
    pass

def \_\_sub\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self-value. """  
    pass

def \_\_xor\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self^value. """  
    pass

class FutureWarning(Warning):
"""
Base class for warnings about constructs that will change semantically
in the future.
"""
def __init__(self, *args, **kwargs): # real signature unknown
pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

class GeneratorExit(BaseException):
""" Request that a generator exit. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

class ImportError(Exception):
""" Import can't find module, or can't find name in module. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

def \_\_reduce\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    pass

def \_\_str\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return str(self). """  
    pass

msg = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""exception message"""

name = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""module name"""

path = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""module path"""

class ImportWarning(Warning):
""" Base class for warnings about probable mistakes in module imports """
def __init__(self, *args, **kwargs): # real signature unknown
pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

class SyntaxError(Exception):
""" Invalid syntax. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

def \_\_str\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return str(self). """  
    pass

filename = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""exception filename"""

lineno = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""exception lineno"""

msg = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""exception msg"""

offset = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""exception offset"""

print\_file\_and\_line = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""exception print\_file\_and\_line"""

text = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""exception text"""

class IndentationError(SyntaxError):
""" Improper indentation. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

class LookupError(Exception):
""" Base class for lookup errors. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

class IndexError(LookupError):
""" Sequence index out of range. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

class InterruptedError(OSError):
""" Interrupted by signal. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

class IsADirectoryError(OSError):
""" Operation doesn't work on directories. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

class KeyboardInterrupt(BaseException):
""" Program interrupted by user. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

class KeyError(LookupError):
""" Mapping key not found. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

def \_\_str\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return str(self). """  
    pass

class list(object):
"""
Built-in mutable sequence.

If no argument is given, the constructor creates a new empty list.  
The argument must be an iterable if specified.  
"""  
def append(self, \*args, \*\*kwargs): # real signature unknown  
    """ Append object to the end of the list. """  
    pass

def clear(self, \*args, \*\*kwargs): # real signature unknown  
    """ Remove all items from list. """  
    pass

def copy(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return a shallow copy of the list. """  
    pass

def count(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return number of occurrences of value. """  
    pass

def extend(self, \*args, \*\*kwargs): # real signature unknown  
    """ Extend list by appending elements from the iterable. """  
    pass

def index(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return first index of value.

    Raises ValueError if the value is not present.  
    """  
    pass

def insert(self, \*args, \*\*kwargs): # real signature unknown  
    """ Insert object before index. """  
    pass

def pop(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Remove and return item at index (default last).

    Raises IndexError if list is empty or index is out of range.  
    """  
    pass

def remove(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Remove first occurrence of value.

    Raises ValueError if the value is not present.  
    """  
    pass

def reverse(self, \*args, \*\*kwargs): # real signature unknown  
    """ Reverse \*IN PLACE\*. """  
    pass

def sort(self, \*args, \*\*kwargs): # real signature unknown  
    """ Stable sort \*IN PLACE\*. """  
    pass

def \_\_add\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self+value. """  
    pass

def \_\_contains\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return key in self. """  
    pass

def \_\_delitem\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Delete self\[key\]. """  
    pass

def \_\_eq\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self==value. """  
    pass

def \_\_getattribute\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return getattr(self, name). """  
    pass

def \_\_getitem\_\_(self, y): # real signature unknown; restored from \_\_doc\_\_  
    """ x.\_\_getitem\_\_(y) <==> x\[y\] """  
    pass

def \_\_ge\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self>=value. """  
    pass

def \_\_gt\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self>value. """  
    pass

def \_\_iadd\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Implement self+=value. """  
    pass

def \_\_imul\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Implement self\*=value. """  
    pass

def \_\_init\_\_(self, seq=()): # known special case of list.\_\_init\_\_  
    """  
    Built-in mutable sequence.

    If no argument is given, the constructor creates a new empty list.  
    The argument must be an iterable if specified.  
    # (copied from class doc)  
    """  
    pass

def \_\_iter\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Implement iter(self). """  
    pass

def \_\_len\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return len(self). """  
    pass

def \_\_le\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self<=value. """  
    pass

def \_\_lt\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self<value. """  
    pass

def \_\_mul\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self\*value. """  
    pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

def \_\_ne\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self!=value. """  
    pass

def \_\_repr\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return repr(self). """  
    pass

def \_\_reversed\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return a reverse iterator over the list. """  
    pass

def \_\_rmul\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return value\*self. """  
    pass

def \_\_setitem\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Set self\[key\] to value. """  
    pass

def \_\_sizeof\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return the size of the list in memory, in bytes. """  
    pass

\_\_hash\_\_ = None

class map(object):
"""
map(func, *iterables) --> map object

Make an iterator that computes the function using arguments from  
each of the iterables.  Stops when the shortest iterable is exhausted.  
"""  
def \_\_getattribute\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return getattr(self, name). """  
    pass

def \_\_init\_\_(self, func, \*iterables): # real signature unknown; restored from \_\_doc\_\_  
    pass

def \_\_iter\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Implement iter(self). """  
    pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

def \_\_next\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Implement next(self). """  
    pass

def \_\_reduce\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return state information for pickling. """  
    pass

class MemoryError(Exception):
""" Out of memory. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

class memoryview(object):
""" Create a new memoryview object which references the given object. """
def cast(self, *args, **kwargs): # real signature unknown
""" Cast a memoryview to a new format or shape. """
pass

def hex(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return the data in the buffer as a string of hexadecimal numbers. """  
    pass

def release(self, \*args, \*\*kwargs): # real signature unknown  
    """ Release the underlying buffer exposed by the memoryview object. """  
    pass

def tobytes(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return the data in the buffer as a byte string. """  
    pass

def tolist(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return the data in the buffer as a list of elements. """  
    pass

def \_\_delitem\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Delete self\[key\]. """  
    pass

def \_\_enter\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    pass

def \_\_eq\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self==value. """  
    pass

def \_\_exit\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    pass

def \_\_getattribute\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return getattr(self, name). """  
    pass

def \_\_getitem\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self\[key\]. """  
    pass

def \_\_ge\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self>=value. """  
    pass

def \_\_gt\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self>value. """  
    pass

def \_\_hash\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return hash(self). """  
    pass

def \_\_init\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    pass

def \_\_len\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return len(self). """  
    pass

def \_\_le\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self<=value. """  
    pass

def \_\_lt\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self<value. """  
    pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

def \_\_ne\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self!=value. """  
    pass

def \_\_repr\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return repr(self). """  
    pass

def \_\_setitem\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Set self\[key\] to value. """  
    pass

contiguous = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""A bool indicating whether the memory is contiguous."""

c\_contiguous = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""A bool indicating whether the memory is C contiguous."""

format = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""A string containing the format (in struct module style)  

for each element in the view."""

f\_contiguous = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""A bool indicating whether the memory is Fortran contiguous."""

itemsize = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""The size in bytes of each element of the memoryview."""

nbytes = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""The amount of space in bytes that the array would use in  

a contiguous representation."""

ndim = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""An integer indicating how many dimensions of a multi-dimensional  

array the memory represents."""

obj = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""The underlying object of the memoryview."""

readonly = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""A bool indicating whether the memory is read only."""

shape = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""A tuple of ndim integers giving the shape of the memory  

as an N-dimensional array."""

strides = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""A tuple of ndim integers giving the size in bytes to access  

each element for each dimension of the array."""

suboffsets = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""A tuple of integers used internally for PIL-style arrays."""

class ModuleNotFoundError(ImportError):
""" Module not found. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

class NameError(Exception):
""" Name not found globally. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

class NotADirectoryError(OSError):
""" Operation only works on directories. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

class RuntimeError(Exception):
""" Unspecified run-time error. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

class NotImplementedError(RuntimeError):
""" Method or function hasn't been implemented yet. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

class OverflowError(ArithmeticError):
""" Result too large to be represented. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

class PendingDeprecationWarning(Warning):
"""
Base class for warnings about features which will be deprecated
in the future.
"""
def __init__(self, *args, **kwargs): # real signature unknown
pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

class PermissionError(OSError):
""" Not enough permissions. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

class ProcessLookupError(OSError):
""" Process not found. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

class property(object):
"""
Property attribute.

  fget  
    function to be used for getting an attribute value  
  fset  
    function to be used for setting an attribute value  
  fdel  
    function to be used for del'ing an attribute  
  doc  
    docstring

Typical use is to define a managed attribute x:

class C(object):  
    def getx(self): return self.\_x  
    def setx(self, value): self.\_x = value  
    def delx(self): del self.\_x  
    x = property(getx, setx, delx, "I'm the 'x' property.")

Decorators make defining new properties or modifying existing ones easy:

class C(object):  
    @property  
    def x(self):  
        "I am the 'x' property."  
        return self.\_x  
    @x.setter  
    def x(self, value):  
        self.\_x = value  
    @x.deleter  
    def x(self):  
        del self.\_x  
"""  
def deleter(self, \*args, \*\*kwargs): # real signature unknown  
    """ Descriptor to change the deleter on a property. """  
    pass

def getter(self, \*args, \*\*kwargs): # real signature unknown  
    """ Descriptor to change the getter on a property. """  
    pass

def setter(self, \*args, \*\*kwargs): # real signature unknown  
    """ Descriptor to change the setter on a property. """  
    pass

def \_\_delete\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Delete an attribute of instance. """  
    pass

def \_\_getattribute\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return getattr(self, name). """  
    pass

def \_\_get\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return an attribute of instance, which is of type owner. """  
    pass

def \_\_init\_\_(self, fget=None, fset=None, fdel=None, doc=None): # known special case of property.\_\_init\_\_  
    """  
    Property attribute.

      fget  
        function to be used for getting an attribute value  
      fset  
        function to be used for setting an attribute value  
      fdel  
        function to be used for del'ing an attribute  
      doc  
        docstring

    Typical use is to define a managed attribute x:

    class C(object):  
        def getx(self): return self.\_x  
        def setx(self, value): self.\_x = value  
        def delx(self): del self.\_x  
        x = property(getx, setx, delx, "I'm the 'x' property.")

    Decorators make defining new properties or modifying existing ones easy:

    class C(object):  
        @property  
        def x(self):  
            "I am the 'x' property."  
            return self.\_x  
        @x.setter  
        def x(self, value):  
            self.\_x = value  
        @x.deleter  
        def x(self):  
            del self.\_x  
    # (copied from class doc)  
    """  
    pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

def \_\_set\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Set an attribute of instance to value. """  
    pass

fdel = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

fget = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

fset = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

\_\_isabstractmethod\_\_ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

class range(object):
"""
range(stop) -> range object
range(start, stop[, step]) -> range object

Return an object that produces a sequence of integers from start (inclusive)  
to stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.  
start defaults to 0, and stop is omitted!  range(4) produces 0, 1, 2, 3.  
These are exactly the valid indices for a list of 4 elements.  
When step is given, it specifies the increment (or decrement).  
"""  
def count(self, value): # real signature unknown; restored from \_\_doc\_\_  
    """ rangeobject.count(value) -> integer -- return number of occurrences of value """  
    return 0

def index(self, value): # real signature unknown; restored from \_\_doc\_\_  
    """  
    rangeobject.index(value) -> integer -- return index of value.  
    Raise ValueError if the value is not present.  
    """  
    return 0

def \_\_bool\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ self != 0 """  
    pass

def \_\_contains\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return key in self. """  
    pass

def \_\_eq\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self==value. """  
    pass

def \_\_getattribute\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return getattr(self, name). """  
    pass

def \_\_getitem\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self\[key\]. """  
    pass

def \_\_ge\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self>=value. """  
    pass

def \_\_gt\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self>value. """  
    pass

def \_\_hash\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return hash(self). """  
    pass

def \_\_init\_\_(self, stop): # real signature unknown; restored from \_\_doc\_\_  
    pass

def \_\_iter\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Implement iter(self). """  
    pass

def \_\_len\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return len(self). """  
    pass

def \_\_le\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self<=value. """  
    pass

def \_\_lt\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self<value. """  
    pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

def \_\_ne\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self!=value. """  
    pass

def \_\_reduce\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    pass

def \_\_repr\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return repr(self). """  
    pass

def \_\_reversed\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return a reverse iterator. """  
    pass

start = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

step = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

stop = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

class RecursionError(RuntimeError):
""" Recursion limit exceeded. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

class ReferenceError(Exception):
""" Weak ref proxy used after referent went away. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

class ResourceWarning(Warning):
""" Base class for warnings about resource usage. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

class reversed(object):
""" Return a reverse iterator over the values of the given sequence. """
def __getattribute__(self, *args, **kwargs): # real signature unknown
""" Return getattr(self, name). """
pass

def \_\_init\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    pass

def \_\_iter\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Implement iter(self). """  
    pass

def \_\_length\_hint\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Private method returning an estimate of len(list(it)). """  
    pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

def \_\_next\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Implement next(self). """  
    pass

def \_\_reduce\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return state information for pickling. """  
    pass

def \_\_setstate\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Set state information for unpickling. """  
    pass

class RuntimeWarning(Warning):
""" Base class for warnings about dubious runtime behavior. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

class set(object):
"""
set() -> new empty set object
set(iterable) -> new set object

Build an unordered collection of unique elements.  
"""  
def add(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Add an element to a set.

    This has no effect if the element is already present.  
    """  
    pass

def clear(self, \*args, \*\*kwargs): # real signature unknown  
    """ Remove all elements from this set. """  
    pass

def copy(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return a shallow copy of a set. """  
    pass

def difference(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return the difference of two or more sets as a new set.

    (i.e. all elements that are in this set but not the others.)  
    """  
    pass

def difference\_update(self, \*args, \*\*kwargs): # real signature unknown  
    """ Remove all elements of another set from this set. """  
    pass

def discard(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Remove an element from a set if it is a member.

    If the element is not a member, do nothing.  
    """  
    pass

def intersection(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return the intersection of two sets as a new set.

    (i.e. all elements that are in both sets.)  
    """  
    pass

def intersection\_update(self, \*args, \*\*kwargs): # real signature unknown  
    """ Update a set with the intersection of itself and another. """  
    pass

def isdisjoint(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return True if two sets have a null intersection. """  
    pass

def issubset(self, \*args, \*\*kwargs): # real signature unknown  
    """ Report whether another set contains this set. """  
    pass

def issuperset(self, \*args, \*\*kwargs): # real signature unknown  
    """ Report whether this set contains another set. """  
    pass

def pop(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Remove and return an arbitrary set element.  
    Raises KeyError if the set is empty.  
    """  
    pass

def remove(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Remove an element from a set; it must be a member.

    If the element is not a member, raise a KeyError.  
    """  
    pass

def symmetric\_difference(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return the symmetric difference of two sets as a new set.

    (i.e. all elements that are in exactly one of the sets.)  
    """  
    pass

def symmetric\_difference\_update(self, \*args, \*\*kwargs): # real signature unknown  
    """ Update a set with the symmetric difference of itself and another. """  
    pass

def union(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return the union of sets as a new set.

    (i.e. all elements that are in either set.)  
    """  
    pass

def update(self, \*args, \*\*kwargs): # real signature unknown  
    """ Update a set with the union of itself and others. """  
    pass

def \_\_and\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self&value. """  
    pass

def \_\_contains\_\_(self, y): # real signature unknown; restored from \_\_doc\_\_  
    """ x.\_\_contains\_\_(y) <==> y in x. """  
    pass

def \_\_eq\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self==value. """  
    pass

def \_\_getattribute\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return getattr(self, name). """  
    pass

def \_\_ge\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self>=value. """  
    pass

def \_\_gt\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self>value. """  
    pass

def \_\_iand\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self&=value. """  
    pass

def \_\_init\_\_(self, seq=()): # known special case of set.\_\_init\_\_  
    """  
    set() -> new empty set object  
    set(iterable) -> new set object

    Build an unordered collection of unique elements.  
    # (copied from class doc)  
    """  
    pass

def \_\_ior\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self|=value. """  
    pass

def \_\_isub\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self-=value. """  
    pass

def \_\_iter\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Implement iter(self). """  
    pass

def \_\_ixor\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self^=value. """  
    pass

def \_\_len\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return len(self). """  
    pass

def \_\_le\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self<=value. """  
    pass

def \_\_lt\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self<value. """  
    pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

def \_\_ne\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self!=value. """  
    pass

def \_\_or\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self|value. """  
    pass

def \_\_rand\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return value&self. """  
    pass

def \_\_reduce\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return state information for pickling. """  
    pass

def \_\_repr\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return repr(self). """  
    pass

def \_\_ror\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return value|self. """  
    pass

def \_\_rsub\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return value-self. """  
    pass

def \_\_rxor\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return value^self. """  
    pass

def \_\_sizeof\_\_(self): # real signature unknown; restored from \_\_doc\_\_  
    """ S.\_\_sizeof\_\_() -> size of S in memory, in bytes """  
    pass

def \_\_sub\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self-value. """  
    pass

def \_\_xor\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self^value. """  
    pass

\_\_hash\_\_ = None

class slice(object):
"""
slice(stop)
slice(start, stop[, step])

Create a slice object.  This is used for extended slicing (e.g. a\[0:10:2\]).  
"""  
def indices(self, len): # real signature unknown; restored from \_\_doc\_\_  
    """  
    S.indices(len) -> (start, stop, stride)

    Assuming a sequence of length len, calculate the start and stop  
    indices, and the stride length of the extended slice described by  
    S. Out of bounds indices are clipped in a manner consistent with the  
    handling of normal slices.  
    """  
    pass

def \_\_eq\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self==value. """  
    pass

def \_\_getattribute\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return getattr(self, name). """  
    pass

def \_\_ge\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self>=value. """  
    pass

def \_\_gt\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self>value. """  
    pass

def \_\_init\_\_(self, stop): # real signature unknown; restored from \_\_doc\_\_  
    pass

def \_\_le\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self<=value. """  
    pass

def \_\_lt\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self<value. """  
    pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

def \_\_ne\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self!=value. """  
    pass

def \_\_reduce\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return state information for pickling. """  
    pass

def \_\_repr\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return repr(self). """  
    pass

start = property(lambda self: 0)  
""":type: int"""

step = property(lambda self: 0)  
""":type: int"""

stop = property(lambda self: 0)  
""":type: int"""

\_\_hash\_\_ = None

class staticmethod(object):
"""
staticmethod(function) -> method

Convert a function to be a static method.

A static method does not receive an implicit first argument.  
To declare a static method, use this idiom:

     class C:  
         @staticmethod  
         def f(arg1, arg2, ...):  
             ...

It can be called either on the class (e.g. C.f()) or on an instance  
(e.g. C().f()).  The instance is ignored except for its class.

Static methods in Python are similar to those found in Java or C++.  
For a more advanced concept, see the classmethod builtin.  
"""  
def \_\_get\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return an attribute of instance, which is of type owner. """  
    pass

def \_\_init\_\_(self, function): # real signature unknown; restored from \_\_doc\_\_  
    pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

\_\_func\_\_ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

\_\_isabstractmethod\_\_ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

\_\_dict\_\_ = None # (!) real value is "mappingproxy({'\_\_get\_\_': <slot wrapper '\_\_get\_\_' of 'staticmethod' objects>, '\_\_init\_\_': <slot wrapper '\_\_init\_\_' of 'staticmethod' objects>, '\_\_new\_\_': <built-in method \_\_new\_\_ of type object at 0x00007FFC494030B0>, '\_\_func\_\_': <member '\_\_func\_\_' of 'staticmethod' objects>, '\_\_isabstractmethod\_\_': <attribute '\_\_isabstractmethod\_\_' of 'staticmethod' objects>, '\_\_dict\_\_': <attribute '\_\_dict\_\_' of 'staticmethod' objects>, '\_\_doc\_\_': 'staticmethod(function) -> method\\\\n\\\\nConvert a function to be a static method.\\\\n\\\\nA static method does not receive an implicit first argument.\\\\nTo declare a static method, use this idiom:\\\\n\\\\n     class C:\\\\n         @staticmethod\\\\n         def f(arg1, arg2, ...):\\\\n             ...\\\\n\\\\nIt can be called either on the class (e.g. C.f()) or on an instance\\\\n(e.g. C().f()).  The instance is ignored except for its class.\\\\n\\\\nStatic methods in Python are similar to those found in Java or C++.\\\\nFor a more advanced concept, see the classmethod builtin.'})"

class StopAsyncIteration(Exception):
""" Signal the end from iterator.__anext__(). """
def __init__(self, *args, **kwargs): # real signature unknown
pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

class StopIteration(Exception):
""" Signal the end from iterator.__next__(). """
def __init__(self, *args, **kwargs): # real signature unknown
pass

value = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""generator return value"""

class str(object):
"""
str(object='') -> str
str(bytes_or_buffer[, encoding[, errors]]) -> str

Create a new string object from the given object. If encoding or  
errors is specified, then the object must expose a data buffer  
that will be decoded using the given encoding and error handler.  
Otherwise, returns the result of object.\_\_str\_\_() (if defined)  
or repr(object).  
encoding defaults to sys.getdefaultencoding().  
errors defaults to 'strict'.  
"""  
def capitalize(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return a capitalized version of the string.

    More specifically, make the first character have upper case and the rest lower  
    case.  
    """  
    pass

def casefold(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return a version of the string suitable for caseless comparisons. """  
    pass

def center(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return a centered string of length width.

    Padding is done using the specified fill character (default is a space).  
    """  
    pass

def count(self, sub, start=None, end=None): # real signature unknown; restored from \_\_doc\_\_  
    """  
    S.count(sub\[, start\[, end\]\]) -> int

    Return the number of non-overlapping occurrences of substring sub in  
    string S\[start:end\].  Optional arguments start and end are  
    interpreted as in slice notation.  
    """  
    return 0

def encode(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Encode the string using the codec registered for encoding.

      encoding  
        The encoding in which to encode the string.  
      errors  
        The error handling scheme to use for encoding errors.  
        The default is 'strict' meaning that encoding errors raise a  
        UnicodeEncodeError.  Other possible values are 'ignore', 'replace' and  
        'xmlcharrefreplace' as well as any other name registered with  
        codecs.register\_error that can handle UnicodeEncodeErrors.  
    """  
    pass

def endswith(self, suffix, start=None, end=None): # real signature unknown; restored from \_\_doc\_\_  
    """  
    S.endswith(suffix\[, start\[, end\]\]) -> bool

    Return True if S ends with the specified suffix, False otherwise.  
    With optional start, test S beginning at that position.  
    With optional end, stop comparing S at that position.  
    suffix can also be a tuple of strings to try.  
    """  
    return False

def expandtabs(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return a copy where all tab characters are expanded using spaces.

    If tabsize is not given, a tab size of 8 characters is assumed.  
    """  
    pass

def find(self, sub, start=None, end=None): # real signature unknown; restored from \_\_doc\_\_  
    """  
    S.find(sub\[, start\[, end\]\]) -> int

    Return the lowest index in S where substring sub is found,  
    such that sub is contained within S\[start:end\].  Optional  
    arguments start and end are interpreted as in slice notation.

    Return -1 on failure.  
    """  
    return 0

def format(self, \*args, \*\*kwargs): # known special case of str.format  
    """  
    S.format(\*args, \*\*kwargs) -> str

    Return a formatted version of S, using substitutions from args and kwargs.  
    The substitutions are identified by braces ('{' and '}').  
    """  
    pass

def format\_map(self, mapping): # real signature unknown; restored from \_\_doc\_\_  
    """  
    S.format\_map(mapping) -> str

    Return a formatted version of S, using substitutions from mapping.  
    The substitutions are identified by braces ('{' and '}').  
    """  
    return ""

def index(self, sub, start=None, end=None): # real signature unknown; restored from \_\_doc\_\_  
    """  
    S.index(sub\[, start\[, end\]\]) -> int

    Return the lowest index in S where substring sub is found,  
    such that sub is contained within S\[start:end\].  Optional  
    arguments start and end are interpreted as in slice notation.

    Raises ValueError when the substring is not found.  
    """  
    return 0

def isalnum(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return True if the string is an alpha-numeric string, False otherwise.

    A string is alpha-numeric if all characters in the string are alpha-numeric and  
    there is at least one character in the string.  
    """  
    pass

def isalpha(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return True if the string is an alphabetic string, False otherwise.

    A string is alphabetic if all characters in the string are alphabetic and there  
    is at least one character in the string.  
    """  
    pass

def isascii(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return True if all characters in the string are ASCII, False otherwise.

    ASCII characters have code points in the range U+0000-U+007F.  
    Empty string is ASCII too.  
    """  
    pass

def isdecimal(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return True if the string is a decimal string, False otherwise.

    A string is a decimal string if all characters in the string are decimal and  
    there is at least one character in the string.  
    """  
    pass

def isdigit(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return True if the string is a digit string, False otherwise.

    A string is a digit string if all characters in the string are digits and there  
    is at least one character in the string.  
    """  
    pass

def isidentifier(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return True if the string is a valid Python identifier, False otherwise.

    Use keyword.iskeyword() to test for reserved identifiers such as "def" and  
    "class".  
    """  
    pass

def islower(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return True if the string is a lowercase string, False otherwise.

    A string is lowercase if all cased characters in the string are lowercase and  
    there is at least one cased character in the string.  
    """  
    pass

def isnumeric(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return True if the string is a numeric string, False otherwise.

    A string is numeric if all characters in the string are numeric and there is at  
    least one character in the string.  
    """  
    pass

def isprintable(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return True if the string is printable, False otherwise.

    A string is printable if all of its characters are considered printable in  
    repr() or if it is empty.  
    """  
    pass

def isspace(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return True if the string is a whitespace string, False otherwise.

    A string is whitespace if all characters in the string are whitespace and there  
    is at least one character in the string.  
    """  
    pass

def istitle(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return True if the string is a title-cased string, False otherwise.

    In a title-cased string, upper- and title-case characters may only  
    follow uncased characters and lowercase characters only cased ones.  
    """  
    pass

def isupper(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return True if the string is an uppercase string, False otherwise.

    A string is uppercase if all cased characters in the string are uppercase and  
    there is at least one cased character in the string.  
    """  
    pass

def join(self, ab=None, pq=None, rs=None): # real signature unknown; restored from \_\_doc\_\_  
    """  
    Concatenate any number of strings.

    The string whose method is called is inserted in between each given string.  
    The result is returned as a new string.

    Example: '.'.join(\['ab', 'pq', 'rs'\]) -> 'ab.pq.rs'  
    """  
    pass

def ljust(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return a left-justified string of length width.

    Padding is done using the specified fill character (default is a space).  
    """  
    pass

def lower(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return a copy of the string converted to lowercase. """  
    pass

def lstrip(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return a copy of the string with leading whitespace removed.

    If chars is given and not None, remove characters in chars instead.  
    """  
    pass

def maketrans(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return a translation table usable for str.translate().

    If there is only one argument, it must be a dictionary mapping Unicode  
    ordinals (integers) or characters to Unicode ordinals, strings or None.  
    Character keys will be then converted to ordinals.  
    If there are two arguments, they must be strings of equal length, and  
    in the resulting dictionary, each character in x will be mapped to the  
    character at the same position in y. If there is a third argument, it  
    must be a string, whose characters will be mapped to None in the result.  
    """  
    pass

def partition(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Partition the string into three parts using the given separator.

    This will search for the separator in the string.  If the separator is found,  
    returns a 3-tuple containing the part before the separator, the separator  
    itself, and the part after it.

    If the separator is not found, returns a 3-tuple containing the original string  
    and two empty strings.  
    """  
    pass

def replace(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return a copy with all occurrences of substring old replaced by new.

      count  
        Maximum number of occurrences to replace.  
        -1 (the default value) means replace all occurrences.

    If the optional argument count is given, only the first count occurrences are  
    replaced.  
    """  
    pass

def rfind(self, sub, start=None, end=None): # real signature unknown; restored from \_\_doc\_\_  
    """  
    S.rfind(sub\[, start\[, end\]\]) -> int

    Return the highest index in S where substring sub is found,  
    such that sub is contained within S\[start:end\].  Optional  
    arguments start and end are interpreted as in slice notation.

    Return -1 on failure.  
    """  
    return 0

def rindex(self, sub, start=None, end=None): # real signature unknown; restored from \_\_doc\_\_  
    """  
    S.rindex(sub\[, start\[, end\]\]) -> int

    Return the highest index in S where substring sub is found,  
    such that sub is contained within S\[start:end\].  Optional  
    arguments start and end are interpreted as in slice notation.

    Raises ValueError when the substring is not found.  
    """  
    return 0

def rjust(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return a right-justified string of length width.

    Padding is done using the specified fill character (default is a space).  
    """  
    pass

def rpartition(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Partition the string into three parts using the given separator.

    This will search for the separator in the string, starting at the end. If  
    the separator is found, returns a 3-tuple containing the part before the  
    separator, the separator itself, and the part after it.

    If the separator is not found, returns a 3-tuple containing two empty strings  
    and the original string.  
    """  
    pass

def rsplit(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return a list of the words in the string, using sep as the delimiter string.

      sep  
        The delimiter according which to split the string.  
        None (the default value) means split according to any whitespace,  
        and discard empty strings from the result.  
      maxsplit  
        Maximum number of splits to do.  
        -1 (the default value) means no limit.

    Splits are done starting at the end of the string and working to the front.  
    """  
    pass

def rstrip(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return a copy of the string with trailing whitespace removed.

    If chars is given and not None, remove characters in chars instead.  
    """  
    pass

def split(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return a list of the words in the string, using sep as the delimiter string.

      sep  
        The delimiter according which to split the string.  
        None (the default value) means split according to any whitespace,  
        and discard empty strings from the result.  
      maxsplit  
        Maximum number of splits to do.  
        -1 (the default value) means no limit.  
    """  
    pass

def splitlines(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return a list of the lines in the string, breaking at line boundaries.

    Line breaks are not included in the resulting list unless keepends is given and  
    true.  
    """  
    pass

def startswith(self, prefix, start=None, end=None): # real signature unknown; restored from \_\_doc\_\_  
    """  
    S.startswith(prefix\[, start\[, end\]\]) -> bool

    Return True if S starts with the specified prefix, False otherwise.  
    With optional start, test S beginning at that position.  
    With optional end, stop comparing S at that position.  
    prefix can also be a tuple of strings to try.  
    """  
    return False

def strip(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return a copy of the string with leading and trailing whitespace removed.

    If chars is given and not None, remove characters in chars instead.  
    """  
    pass

def swapcase(self, \*args, \*\*kwargs): # real signature unknown  
    """ Convert uppercase characters to lowercase and lowercase characters to uppercase. """  
    pass

def title(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return a version of the string where each word is titlecased.

    More specifically, words start with uppercased characters and all remaining  
    cased characters have lower case.  
    """  
    pass

def translate(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Replace each character in the string using the given translation table.

      table  
        Translation table, which must be a mapping of Unicode ordinals to  
        Unicode ordinals, strings, or None.

    The table must implement lookup/indexing via \_\_getitem\_\_, for instance a  
    dictionary or list.  If this operation raises LookupError, the character is  
    left untouched.  Characters mapped to None are deleted.  
    """  
    pass

def upper(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return a copy of the string converted to uppercase. """  
    pass

def zfill(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Pad a numeric string with zeros on the left, to fill a field of the given width.

    The string is never truncated.  
    """  
    pass

def \_\_add\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self+value. """  
    pass

def \_\_contains\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return key in self. """  
    pass

def \_\_eq\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self==value. """  
    pass

def \_\_format\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return a formatted version of the string as described by format\_spec. """  
    pass

def \_\_getattribute\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return getattr(self, name). """  
    pass

def \_\_getitem\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self\[key\]. """  
    pass

def \_\_getnewargs\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    pass

def \_\_ge\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self>=value. """  
    pass

def \_\_gt\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self>value. """  
    pass

def \_\_hash\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return hash(self). """  
    pass

def \_\_init\_\_(self, value='', encoding=None, errors='strict'): # known special case of str.\_\_init\_\_  
    """  
    str(object='') -> str  
    str(bytes\_or\_buffer\[, encoding\[, errors\]\]) -> str

    Create a new string object from the given object. If encoding or  
    errors is specified, then the object must expose a data buffer  
    that will be decoded using the given encoding and error handler.  
    Otherwise, returns the result of object.\_\_str\_\_() (if defined)  
    or repr(object).  
    encoding defaults to sys.getdefaultencoding().  
    errors defaults to 'strict'.  
    # (copied from class doc)  
    """  
    pass

def \_\_iter\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Implement iter(self). """  
    pass

def \_\_len\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return len(self). """  
    pass

def \_\_le\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self<=value. """  
    pass

def \_\_lt\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self<value. """  
    pass

def \_\_mod\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self%value. """  
    pass

def \_\_mul\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self\*value. """  
    pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

def \_\_ne\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self!=value. """  
    pass

def \_\_repr\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return repr(self). """  
    pass

def \_\_rmod\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return value%self. """  
    pass

def \_\_rmul\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return value\*self. """  
    pass

def \_\_sizeof\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return the size of the string in memory, in bytes. """  
    pass

def \_\_str\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return str(self). """  
    pass

class super(object):
"""
super() -> same as super(__class__, )
super(type) -> unbound super object
super(type, obj) -> bound super object; requires isinstance(obj, type)
super(type, type2) -> bound super object; requires issubclass(type2, type)
Typical use to call a cooperative superclass method:
class C(B):
def meth(self, arg):
super().meth(arg)
This works for class methods too:
class C(B):
@classmethod
def cmeth(cls, arg):
super().cmeth(arg)
"""
def __getattribute__(self, *args, **kwargs): # real signature unknown
""" Return getattr(self, name). """
pass

def \_\_get\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return an attribute of instance, which is of type owner. """  
    pass

def \_\_init\_\_(self, type1=None, type2=None): # known special case of super.\_\_init\_\_  
    """  
    super() -> same as super(\_\_class\_\_, <first argument>)  
    super(type) -> unbound super object  
    super(type, obj) -> bound super object; requires isinstance(obj, type)  
    super(type, type2) -> bound super object; requires issubclass(type2, type)  
    Typical use to call a cooperative superclass method:  
    class C(B):  
        def meth(self, arg):  
            super().meth(arg)  
    This works for class methods too:  
    class C(B):  
        @classmethod  
        def cmeth(cls, arg):  
            super().cmeth(arg)

    # (copied from class doc)  
    """  
    pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

def \_\_repr\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return repr(self). """  
    pass

\_\_self\_class\_\_ = property(lambda self: type(object))  
"""the type of the instance invoking super(); may be None

:type: type  
"""

\_\_self\_\_ = property(lambda self: type(object))  
"""the instance invoking super(); may be None

:type: type  
"""

\_\_thisclass\_\_ = property(lambda self: type(object))  
"""the class invoking super()

:type: type  
"""

class SyntaxWarning(Warning):
""" Base class for warnings about dubious syntax. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

class SystemError(Exception):
"""
Internal error in the Python interpreter.

Please report this to the Python maintainer, along with the traceback,  
the Python version, and the hardware/OS platform and version.  
"""  
def \_\_init\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

class SystemExit(BaseException):
""" Request to exit from the interpreter. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

code = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""exception code"""

class TabError(IndentationError):
""" Improper mixture of spaces and tabs. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

class TimeoutError(OSError):
""" Timeout expired. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

class tuple(object):
"""
Built-in immutable sequence.

If no argument is given, the constructor returns an empty tuple.  
If iterable is specified the tuple is initialized from iterable's items.

If the argument is a tuple, the return value is the same object.  
"""  
def count(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return number of occurrences of value. """  
    pass

def index(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Return first index of value.

    Raises ValueError if the value is not present.  
    """  
    pass

def \_\_add\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self+value. """  
    pass

def \_\_contains\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return key in self. """  
    pass

def \_\_eq\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self==value. """  
    pass

def \_\_getattribute\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return getattr(self, name). """  
    pass

def \_\_getitem\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self\[key\]. """  
    pass

def \_\_getnewargs\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    pass

def \_\_ge\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self>=value. """  
    pass

def \_\_gt\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self>value. """  
    pass

def \_\_hash\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return hash(self). """  
    pass

def \_\_init\_\_(self, seq=()): # known special case of tuple.\_\_init\_\_  
    """  
    Built-in immutable sequence.

    If no argument is given, the constructor returns an empty tuple.  
    If iterable is specified the tuple is initialized from iterable's items.

    If the argument is a tuple, the return value is the same object.  
    # (copied from class doc)  
    """  
    pass

def \_\_iter\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Implement iter(self). """  
    pass

def \_\_len\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return len(self). """  
    pass

def \_\_le\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self<=value. """  
    pass

def \_\_lt\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self<value. """  
    pass

def \_\_mul\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self\*value. """  
    pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

def \_\_ne\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return self!=value. """  
    pass

def \_\_repr\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return repr(self). """  
    pass

def \_\_rmul\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return value\*self. """  
    pass

class type(object):
"""
type(object_or_name, bases, dict)
type(object) -> the object's type
type(name, bases, dict) -> a new type
"""
def mro(self, *args, **kwargs): # real signature unknown
""" Return a type's method resolution order. """
pass

def \_\_call\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Call self as a function. """  
    pass

def \_\_delattr\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Implement delattr(self, name). """  
    pass

def \_\_dir\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Specialized \_\_dir\_\_ implementation for types. """  
    pass

def \_\_getattribute\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return getattr(self, name). """  
    pass

def \_\_init\_\_(cls, what, bases=None, dict=None): # known special case of type.\_\_init\_\_  
    """  
    type(object\_or\_name, bases, dict)  
    type(object) -> the object's type  
    type(name, bases, dict) -> a new type  
    # (copied from class doc)  
    """  
    pass

def \_\_instancecheck\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Check if an object is an instance. """  
    pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

def \_\_prepare\_\_(self): # real signature unknown; restored from \_\_doc\_\_  
    """  
    \_\_prepare\_\_() -> dict  
    used to create the namespace for the class statement  
    """  
    return {}

def \_\_repr\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return repr(self). """  
    pass

def \_\_setattr\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Implement setattr(self, name, value). """  
    pass

def \_\_sizeof\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return memory consumption of the type object. """  
    pass

def \_\_subclasscheck\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Check if a class is a subclass. """  
    pass

def \_\_subclasses\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return a list of immediate subclasses. """  
    pass

\_\_abstractmethods\_\_ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default

\_\_bases\_\_ = (  
    object,  
)  
\_\_base\_\_ = object  
\_\_basicsize\_\_ = 864  
\_\_dictoffset\_\_ = 264  
\_\_dict\_\_ = None # (!) real value is "mappingproxy({'\_\_repr\_\_': <slot wrapper '\_\_repr\_\_' of 'type' objects>, '\_\_call\_\_': <slot wrapper '\_\_call\_\_' of 'type' objects>, '\_\_getattribute\_\_': <slot wrapper '\_\_getattribute\_\_' of 'type' objects>, '\_\_setattr\_\_': <slot wrapper '\_\_setattr\_\_' of 'type' objects>, '\_\_delattr\_\_': <slot wrapper '\_\_delattr\_\_' of 'type' objects>, '\_\_init\_\_': <slot wrapper '\_\_init\_\_' of 'type' objects>, '\_\_new\_\_': <built-in method \_\_new\_\_ of type object at 0x00007FFC494069A0>, 'mro': <method 'mro' of 'type' objects>, '\_\_subclasses\_\_': <method '\_\_subclasses\_\_' of 'type' objects>, '\_\_prepare\_\_': <method '\_\_prepare\_\_' of 'type' objects>, '\_\_instancecheck\_\_': <method '\_\_instancecheck\_\_' of 'type' objects>, '\_\_subclasscheck\_\_': <method '\_\_subclasscheck\_\_' of 'type' objects>, '\_\_dir\_\_': <method '\_\_dir\_\_' of 'type' objects>, '\_\_sizeof\_\_': <method '\_\_sizeof\_\_' of 'type' objects>, '\_\_basicsize\_\_': <member '\_\_basicsize\_\_' of 'type' objects>, '\_\_itemsize\_\_': <member '\_\_itemsize\_\_' of 'type' objects>, '\_\_flags\_\_': <member '\_\_flags\_\_' of 'type' objects>, '\_\_weakrefoffset\_\_': <member '\_\_weakrefoffset\_\_' of 'type' objects>, '\_\_base\_\_': <member '\_\_base\_\_' of 'type' objects>, '\_\_dictoffset\_\_': <member '\_\_dictoffset\_\_' of 'type' objects>, '\_\_mro\_\_': <member '\_\_mro\_\_' of 'type' objects>, '\_\_name\_\_': <attribute '\_\_name\_\_' of 'type' objects>, '\_\_qualname\_\_': <attribute '\_\_qualname\_\_' of 'type' objects>, '\_\_bases\_\_': <attribute '\_\_bases\_\_' of 'type' objects>, '\_\_module\_\_': <attribute '\_\_module\_\_' of 'type' objects>, '\_\_abstractmethods\_\_': <attribute '\_\_abstractmethods\_\_' of 'type' objects>, '\_\_dict\_\_': <attribute '\_\_dict\_\_' of 'type' objects>, '\_\_doc\_\_': <attribute '\_\_doc\_\_' of 'type' objects>, '\_\_text\_signature\_\_': <attribute '\_\_text\_signature\_\_' of 'type' objects>})"  
\_\_flags\_\_ = 2148291584  
\_\_itemsize\_\_ = 40  
\_\_mro\_\_ = (  
    None, # (!) forward: type, real value is "<class 'type'>"  
    object,  
)  
\_\_name\_\_ = 'type'  
\_\_qualname\_\_ = 'type'  
\_\_text\_signature\_\_ = None  
\_\_weakrefoffset\_\_ = 368

class TypeError(Exception):
""" Inappropriate argument type. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

class UnboundLocalError(NameError):
""" Local name referenced but not bound to a value. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

class ValueError(Exception):
""" Inappropriate argument value (of correct type). """
def __init__(self, *args, **kwargs): # real signature unknown
pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

class UnicodeError(ValueError):
""" Unicode related error. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

class UnicodeDecodeError(UnicodeError):
""" Unicode decoding error. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

def \_\_str\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return str(self). """  
    pass

encoding = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""exception encoding"""

end = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""exception end"""

object = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""exception object"""

reason = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""exception reason"""

start = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""exception start"""

class UnicodeEncodeError(UnicodeError):
""" Unicode encoding error. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

def \_\_str\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return str(self). """  
    pass

encoding = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""exception encoding"""

end = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""exception end"""

object = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""exception object"""

reason = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""exception reason"""

start = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""exception start"""

class UnicodeTranslateError(UnicodeError):
""" Unicode translation error. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

def \_\_str\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return str(self). """  
    pass

encoding = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""exception encoding"""

end = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""exception end"""

object = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""exception object"""

reason = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""exception reason"""

start = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""exception start"""

class UnicodeWarning(Warning):
"""
Base class for warnings about Unicode related problems, mostly
related to conversion problems.
"""
def __init__(self, *args, **kwargs): # real signature unknown
pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

class UserWarning(Warning):
""" Base class for warnings generated by user code. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

class ZeroDivisionError(ArithmeticError):
""" Second argument to a division or modulo operation was zero. """
def __init__(self, *args, **kwargs): # real signature unknown
pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

class zip(object):
"""
zip(*iterables) --> zip object

Return a zip object whose .\_\_next\_\_() method returns a tuple where  
the i-th element comes from the i-th iterable argument.  The .\_\_next\_\_()  
method continues until the shortest iterable in the argument sequence  
is exhausted and then it raises StopIteration.  
"""  
def \_\_getattribute\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return getattr(self, name). """  
    pass

def \_\_init\_\_(self, \*iterables): # real signature unknown; restored from \_\_doc\_\_  
    pass

def \_\_iter\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Implement iter(self). """  
    pass

@staticmethod # known case of \_\_new\_\_  
def \_\_new\_\_(\*args, \*\*kwargs): # real signature unknown  
    """ Create and return a new object.  See help(type) for accurate signature. """  
    pass

def \_\_next\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Implement next(self). """  
    pass

def \_\_reduce\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return state information for pickling. """  
    pass

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, \*args, \*\*kwargs): # real signature unknown  
    """ Create a built-in module """  
    pass

def exec\_module(self, \*args, \*\*kwargs): # real signature unknown  
    """ Exec a built-in module """  
    pass

def find\_module(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    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, \*args, \*\*kwargs): # real signature unknown  
    pass

def get\_code(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return None as built-in modules do not have code objects. """  
    pass

def get\_source(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return None as built-in modules do not have source code. """  
    pass

def is\_package(self, \*args, \*\*kwargs): # real signature unknown  
    """ Return False as built-in modules are never packages. """  
    pass

def load\_module(self, \*args, \*\*kwargs): # real signature unknown  
    """  
    Load the specified module into sys.modules and return it.

        This method is deprecated.  Use loader.exec\_module instead.  
    """  
    pass

def module\_repr(module): # reliably restored by inspect  
    """  
    Return repr for the module.

            The method is deprecated.  The import machinery does the job itself.  
    """  
    pass

def \_\_init\_\_(self, \*args, \*\*kwargs): # real signature unknown  
    pass

\_\_weakref\_\_ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default  
"""list of weak references to the object (if defined)"""

\_\_dict\_\_ = None # (!) real value is "mappingproxy({'\_\_module\_\_': '\_frozen\_importlib', '\_\_doc\_\_': 'Meta path import for built-in modules.\\\\n\\\\n    All methods are either class or static methods to avoid the need to\\\\n    instantiate the class.\\\\n\\\\n    ', 'module\_repr': <staticmethod object at 0x00000233C28F6FC8>, 'find\_spec': <classmethod object at 0x00000233C28FE048>, 'find\_module': <classmethod object at 0x00000233C28FE088>, 'create\_module': <classmethod object at 0x00000233C28FE0C8>, 'exec\_module': <classmethod object at 0x00000233C28FE108>, 'get\_code': <classmethod object at 0x00000233C28FE188>, 'get\_source': <classmethod object at 0x00000233C28FE208>, 'is\_package': <classmethod object at 0x00000233C28FE288>, 'load\_module': <classmethod object at 0x00000233C28FE2C8>, '\_\_dict\_\_': <attribute '\_\_dict\_\_' of 'BuiltinImporter' objects>, '\_\_weakref\_\_': <attribute '\_\_weakref\_\_' of 'BuiltinImporter' objects>})"

variables with complex values

Ellipsis = None # (!) real value is 'Ellipsis'

NotImplemented = None # (!) real value is 'NotImplemented'

__spec__ = None # (!) real value is "ModuleSpec(name='builtins', loader=)"