>>> a = 1>>> dir(a)[‘__abs__‘, ‘__add__‘, ‘__and__‘, ‘__class__‘, ‘__cmp__‘, ‘__coerce__‘, ‘__delattr__‘, ‘__div__‘, ‘__divmod__‘, ‘__doc__‘, ‘__float__‘, ‘__floordiv__‘, ‘__format__‘, ‘__getattribute__‘, ‘__getnewargs__‘, ‘__hash__‘, ‘__hex__‘, ‘__index__‘, ‘__init__‘, ‘__int__‘, ‘__invert__‘, ‘__long__‘, ‘__lshift__‘, ‘__mod__‘, ‘__mul__‘, ‘__neg__‘, ‘__new__‘, ‘__nonzero__‘, ‘__oct__‘, ‘__or__‘, ‘__pos__‘, ‘__pow__‘, ‘__radd__‘, ‘__rand__‘, ‘__rdiv__‘, ‘__rdivmod__‘, ‘__reduce__‘, ‘__reduce_ex__‘, ‘__repr__‘, ‘__rfloordiv__‘, ‘__rlshift__‘, ‘__rmod__‘, ‘__rmul__‘, ‘__ror__‘, ‘__rpow__‘, ‘__rrshift__‘, ‘__rshift__‘, ‘__rsub__‘, ‘__rtruediv__‘, ‘__rxor__‘, ‘__setattr__‘, ‘__sizeof__‘, ‘__str__‘, ‘__sub__‘, ‘__subclasshook__‘, ‘__truediv__‘, ‘__trunc__‘, ‘__xor__‘, ‘bit_length‘, ‘conjugate‘, ‘denominator‘, ‘imag‘, ‘numerator‘, ‘real‘]>>> type(a)<type ‘int‘>

class int(object):    """    int(x=0) -> int or long    int(x, base=10) -> int or long        Convert a number or string to an integer, or return 0 if no arguments    are given.  If x is floating point, the conversion truncates towards zero.    If x is outside the integer range, the function returns a long instead.        If x is not a number or if base is given, then x must be a string or    Unicode object 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__        """        int.bit_length() -> int                Number of bits necessary to represent self in binary.        >>> bin(37)        ‘0b100101‘        >>> (37).bit_length()        6        """        return 0    def conjugate(self, *args, **kwargs): # real signature unknown        """ Returns self, the complex conjugate of any int. """        pass    def __abs__(self): # real signature unknown; restored from __doc__        """ x.__abs__() <==> abs(x) """        pass    def __add__(self, y): # real signature unknown; restored from __doc__        """ x.__add__(y) <==> x+y """        pass    def __and__(self, y): # real signature unknown; restored from __doc__        """ x.__and__(y) <==> x&y """        pass    def __cmp__(self, y): # real signature unknown; restored from __doc__        """ x.__cmp__(y) <==> cmp(x,y) """        pass    def __coerce__(self, y): # real signature unknown; restored from __doc__        """ x.__coerce__(y) <==> coerce(x, y) """        pass    def __divmod__(self, y): # real signature unknown; restored from __doc__        """ x.__divmod__(y) <==> divmod(x, y) """        pass    def __div__(self, y): # real signature unknown; restored from __doc__        """ x.__div__(y) <==> x/y """        pass    def __float__(self): # real signature unknown; restored from __doc__        """ x.__float__() <==> float(x) """        pass    def __floordiv__(self, y): # real signature unknown; restored from __doc__        """ x.__floordiv__(y) <==> x//y """        pass    def __format__(self, *args, **kwargs): # real signature unknown        pass    def __getattribute__(self, name): # real signature unknown; restored from __doc__        """ x.__getattribute__(‘name‘) <==> x.name """        pass    def __getnewargs__(self, *args, **kwargs): # real signature unknown        pass    def __hash__(self): # real signature unknown; restored from __doc__        """ x.__hash__() <==> hash(x) """        pass    def __hex__(self): # real signature unknown; restored from __doc__        """ x.__hex__() <==> hex(x) """        pass    def __index__(self): # real signature unknown; restored from __doc__        """ x[y:z] <==> x[y.__index__():z.__index__()] """        pass    def __init__(self, x, base=10): # known special case of int.__init__        """        int(x=0) -> int or long        int(x, base=10) -> int or long                Convert a number or string to an integer, or return 0 if no arguments        are given.  If x is floating point, the conversion truncates towards zero.        If x is outside the integer range, the function returns a long instead.                If x is not a number or if base is given, then x must be a string or        Unicode object 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): # real signature unknown; restored from __doc__        """ x.__int__() <==> int(x) """        pass    def __invert__(self): # real signature unknown; restored from __doc__        """ x.__invert__() <==> ~x """        pass    def __long__(self): # real signature unknown; restored from __doc__        """ x.__long__() <==> long(x) """        pass    def __lshift__(self, y): # real signature unknown; restored from __doc__        """ x.__lshift__(y) <==> x<<y """        pass    def __mod__(self, y): # real signature unknown; restored from __doc__        """ x.__mod__(y) <==> x%y """        pass    def __mul__(self, y): # real signature unknown; restored from __doc__        """ x.__mul__(y) <==> x*y """        pass    def __neg__(self): # real signature unknown; restored from __doc__        """ x.__neg__() <==> -x """        pass    @staticmethod # known case of __new__    def __new__(S, *more): # real signature unknown; restored from __doc__        """ T.__new__(S, ...) -> a new object with type S, a subtype of T """        pass    def __nonzero__(self): # real signature unknown; restored from __doc__        """ x.__nonzero__() <==> x != 0 """        pass    def __oct__(self): # real signature unknown; restored from __doc__        """ x.__oct__() <==> oct(x) """        pass    def __or__(self, y): # real signature unknown; restored from __doc__        """ x.__or__(y) <==> x|y """        pass    def __pos__(self): # real signature unknown; restored from __doc__        """ x.__pos__() <==> +x """        pass    def __pow__(self, y, z=None): # real signature unknown; restored from __doc__        """ x.__pow__(y[, z]) <==> pow(x, y[, z]) """        pass    def __radd__(self, y): # real signature unknown; restored from __doc__        """ x.__radd__(y) <==> y+x """        pass    def __rand__(self, y): # real signature unknown; restored from __doc__        """ x.__rand__(y) <==> y&x """        pass    def __rdivmod__(self, y): # real signature unknown; restored from __doc__        """ x.__rdivmod__(y) <==> divmod(y, x) """        pass    def __rdiv__(self, y): # real signature unknown; restored from __doc__        """ x.__rdiv__(y) <==> y/x """        pass    def __repr__(self): # real signature unknown; restored from __doc__        """ x.__repr__() <==> repr(x) """        pass    def __rfloordiv__(self, y): # real signature unknown; restored from __doc__        """ x.__rfloordiv__(y) <==> y//x """        pass    def __rlshift__(self, y): # real signature unknown; restored from __doc__        """ x.__rlshift__(y) <==> y<<x """        pass    def __rmod__(self, y): # real signature unknown; restored from __doc__        """ x.__rmod__(y) <==> y%x """        pass    def __rmul__(self, y): # real signature unknown; restored from __doc__        """ x.__rmul__(y) <==> y*x """        pass    def __ror__(self, y): # real signature unknown; restored from __doc__        """ x.__ror__(y) <==> y|x """        pass    def __rpow__(self, x, z=None): # real signature unknown; restored from __doc__        """ y.__rpow__(x[, z]) <==> pow(x, y[, z]) """        pass    def __rrshift__(self, y): # real signature unknown; restored from __doc__        """ x.__rrshift__(y) <==> y>>x """        pass    def __rshift__(self, y): # real signature unknown; restored from __doc__        """ x.__rshift__(y) <==> x>>y """        pass    def __rsub__(self, y): # real signature unknown; restored from __doc__        """ x.__rsub__(y) <==> y-x """        pass    def __rtruediv__(self, y): # real signature unknown; restored from __doc__        """ x.__rtruediv__(y) <==> y/x """        pass    def __rxor__(self, y): # real signature unknown; restored from __doc__        """ x.__rxor__(y) <==> y^x """        pass    def __str__(self): # real signature unknown; restored from __doc__        """ x.__str__() <==> str(x) """        pass    def __sub__(self, y): # real signature unknown; restored from __doc__        """ x.__sub__(y) <==> x-y """        pass    def __truediv__(self, y): # real signature unknown; restored from __doc__        """ x.__truediv__(y) <==> x/y """        pass    def __trunc__(self, *args, **kwargs): # real signature unknown        """ Truncating an Integral returns itself. """        pass    def __xor__(self, y): # real signature unknown; restored from __doc__        """ x.__xor__(y) <==> x^y """        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, y): # real signature unknown; restored from __doc__        """ x.__and__(y) <==> x&y """        pass    def __init__(self, x): # real signature unknown; restored from __doc__        pass    @staticmethod # known case of __new__    def __new__(S, *more): # real signature unknown; restored from __doc__        """ T.__new__(S, ...) -> a new object with type S, a subtype of T """        pass    def __or__(self, y): # real signature unknown; restored from __doc__        """ x.__or__(y) <==> x|y """        pass    def __rand__(self, y): # real signature unknown; restored from __doc__        """ x.__rand__(y) <==> y&x """        pass    def __repr__(self): # real signature unknown; restored from __doc__        """ x.__repr__() <==> repr(x) """        pass    def __ror__(self, y): # real signature unknown; restored from __doc__        """ x.__ror__(y) <==> y|x """        pass    def __rxor__(self, y): # real signature unknown; restored from __doc__        """ x.__rxor__(y) <==> y^x """        pass    def __str__(self): # real signature unknown; restored from __doc__        """ x.__str__() <==> str(x) """        pass    def __xor__(self, y): # real signature unknown; restored from __doc__        """ x.__xor__(y) <==> x^y """        passclass buffer(object):    """    buffer(object [, offset[, size]])        Create a new buffer object which references the given object.    The buffer will reference a slice of the target object from the    start of the object (or at the specified offset). The slice will    extend to the end of the target object (or with the specified size).    """    def __add__(self, y): # real signature unknown; restored from __doc__        """ x.__add__(y) <==> x+y """        pass    def __cmp__(self, y): # real signature unknown; restored from __doc__        """ x.__cmp__(y) <==> cmp(x,y) """        pass    def __delitem__(self, y): # real signature unknown; restored from __doc__        """ x.__delitem__(y) <==> del x[y] """        pass    def __delslice__(self, i, j): # real signature unknown; restored from __doc__        """        x.__delslice__(i, j) <==> del x[i:j]                                      Use of negative indices is not supported.        """        pass    def __getattribute__(self, name): # real signature unknown; restored from __doc__        """ x.__getattribute__(‘name‘) <==> x.name """        pass    def __getitem__(self, y): # real signature unknown; restored from __doc__        """ x.__getitem__(y) <==> x[y] """        pass    def __getslice__(self, i, j): # real signature unknown; restored from __doc__        """        x.__getslice__(i, j) <==> x[i:j]                                      Use of negative indices is not supported.        """        pass    def __hash__(self): # real signature unknown; restored from __doc__        """ x.__hash__() <==> hash(x) """        pass    def __init__(self, p_object, offset=None, size=None): # real signature unknown; restored from __doc__        pass    def __len__(self): # real signature unknown; restored from __doc__        """ x.__len__() <==> len(x) """        pass    def __mul__(self, n): # real signature unknown; restored from __doc__        """ x.__mul__(n) <==> x*n """        pass    @staticmethod # known case of __new__    def __new__(S, *more): # real signature unknown; restored from __doc__        """ T.__new__(S, ...) -> a new object with type S, a subtype of T """        pass    def __repr__(self): # real signature unknown; restored from __doc__        """ x.__repr__() <==> repr(x) """        pass    def __rmul__(self, n): # real signature unknown; restored from __doc__        """ x.__rmul__(n) <==> n*x """        pass    def __setitem__(self, i, y): # real signature unknown; restored from __doc__        """ x.__setitem__(i, y) <==> x[i]=y """        pass    def __setslice__(self, i, j, y): # real signature unknown; restored from __doc__        """        x.__setslice__(i, j, y) <==> x[i:j]=y                                      Use  of negative indices is not supported.        """        pass    def __str__(self): # real signature unknown; restored from __doc__        """ x.__str__() <==> str(x) """        passclass bytearray(object):    """    bytearray(iterable_of_ints) -> bytearray.    bytearray(string, encoding[, errors]) -> bytearray.    bytearray(bytes_or_bytearray) -> mutable copy of bytes_or_bytearray.    bytearray(memory_view) -> bytearray.        Construct an mutable bytearray object from:      - an iterable yielding integers in range(256)      - a text string encoded using the specified encoding      - a bytes or a bytearray object      - any object implementing the buffer API.        bytearray(int) -> bytearray.        Construct a zero-initialized bytearray of the given length.    """    def append(self, p_int): # real signature unknown; restored from __doc__        """        B.append(int) -> None                Append a single item to the end of B.        """        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 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, encoding=None, errors=None): # real signature unknown; restored from __doc__        """        B.decode([encoding[, errors]]) -> unicode object.                Decodes B using the codec registered for encoding. encoding defaults        to the default encoding. errors may be given to set a different error        handling scheme.  Default is ‘strict‘ meaning that encoding errors raise        a UnicodeDecodeError.  Other possible values are ‘ignore‘ and ‘replace‘        as well as any other name registered with codecs.register_error that is        able to handle UnicodeDecodeErrors.        """        return u""    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 strings to try.        """        return False    def expandtabs(self, tabsize=None): # real signature unknown; restored from __doc__        """        B.expandtabs([tabsize]) -> 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, iterable_int): # real signature unknown; restored from __doc__        """        B.extend(iterable int) -> None                Append all the elements from the iterator or sequence to the        end of B.        """        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, string): # real signature unknown; restored from __doc__        """        bytearray.fromhex(string) -> bytearray                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‘).        """        return bytearray    def index(self, sub, start=None, end=None): # real signature unknown; restored from __doc__        """        B.index(sub [,start [,end]]) -> int                Like B.find() but raise ValueError when the subsection is not found.        """        return 0    def insert(self, index, p_int): # real signature unknown; restored from __doc__        """        B.insert(index, int) -> None                Insert a single item into the bytearray before the given index.        """        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 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, iterable_of_bytes): # real signature unknown; restored from __doc__        """        B.join(iterable_of_bytes) -> bytes                Concatenates any number of bytearray objects, with B in between each pair.        """        return ""    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, bytes=None): # real signature unknown; restored from __doc__        """        B.lstrip([bytes]) -> bytearray                Strip leading bytes contained in the argument.        If the argument is omitted, strip leading ASCII whitespace.        """        return bytearray    def partition(self, sep): # real signature unknown; restored from __doc__        """        B.partition(sep) -> (head, sep, tail)                Searches for the separator sep in B, and returns the part before it,        the separator itself, and the part after it.  If the separator is not        found, returns B and two empty bytearray objects.        """        pass    def pop(self, index=None): # real signature unknown; restored from __doc__        """        B.pop([index]) -> int                Remove and return a single item from B. If no index        argument is given, will pop the last value.        """        return 0    def remove(self, p_int): # real signature unknown; restored from __doc__        """        B.remove(int) -> None                Remove the first occurance of a value in B.        """        pass    def replace(self, old, new, count=None): # real signature unknown; restored from __doc__        """        B.replace(old, new[, count]) -> bytes                Return a copy of B with all occurrences of subsection        old replaced by new.  If the optional argument count is        given, only the first count occurrences are replaced.        """        return ""    def reverse(self): # real signature unknown; restored from __doc__        """        B.reverse() -> None                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                Like B.rfind() but 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, sep): # real signature unknown; restored from __doc__        """        B.rpartition(sep) -> (head, sep, tail)                Searches for the separator sep in B, starting at the end of B,        and returns the part before it, the separator itself, and the        part after it.  If the separator is not found, returns two empty        bytearray objects and B.        """        pass    def rsplit(self, sep, maxsplit=None): # real signature unknown; restored from __doc__        """        B.rsplit(sep[, maxsplit]) -> list of bytearray                Return a list of the sections in B, using sep as the delimiter,        starting at the end of B and working to the front.        If sep is not given, B is split on ASCII whitespace characters        (space, tab, return, newline, formfeed, vertical tab).        If maxsplit is given, at most maxsplit splits are done.        """        return []    def rstrip(self, bytes=None): # real signature unknown; restored from __doc__        """        B.rstrip([bytes]) -> bytearray                Strip trailing bytes contained in the argument.        If the argument is omitted, strip trailing ASCII whitespace.        """        return bytearray    def split(self, sep=None, maxsplit=None): # real signature unknown; restored from __doc__        """        B.split([sep[, maxsplit]]) -> list of bytearray                Return a list of the sections in B, using sep as the delimiter.        If sep is not given, B is split on ASCII whitespace characters        (space, tab, return, newline, formfeed, vertical tab).        If maxsplit is given, at most maxsplit splits are done.        """        return []    def splitlines(self, keepends=False): # real signature unknown; restored from __doc__        """        B.splitlines(keepends=False) -> list of lines                Return a list of the lines in B, breaking at line boundaries.        Line breaks are not included in the resulting list unless keepends        is given and true.        """        return []    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 strings to try.        """        return False    def strip(self, bytes=None): # real signature unknown; restored from __doc__        """        B.strip([bytes]) -> bytearray                Strip leading and trailing bytes contained in the argument.        If the argument is omitted, strip ASCII whitespace.        """        return bytearray    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, table, deletechars=None): # real signature unknown; restored from __doc__        """        B.translate(table[, deletechars]) -> bytearray                Return a copy of B, where all characters occurring in the        optional argument deletechars are removed, and the remaining        characters have been mapped through the given translation        table, which must be a bytes object of length 256.        """        return bytearray    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, y): # real signature unknown; restored from __doc__        """ x.__add__(y) <==> x+y """        pass    def __alloc__(self): # real signature unknown; restored from __doc__        """        B.__alloc__() -> int                Returns the number of bytes actually allocated.        """        return 0    def __contains__(self, y): # real signature unknown; restored from __doc__        """ x.__contains__(y) <==> y in x """        pass    def __delitem__(self, y): # real signature unknown; restored from __doc__        """ x.__delitem__(y) <==> del x[y] """        pass    def __eq__(self, y): # real signature unknown; restored from __doc__        """ x.__eq__(y) <==> x==y """        pass    def __getattribute__(self, name): # real signature unknown; restored from __doc__        """ x.__getattribute__(‘name‘) <==> x.name """        pass    def __getitem__(self, y): # real signature unknown; restored from __doc__        """ x.__getitem__(y) <==> x[y] """        pass    def __ge__(self, y): # real signature unknown; restored from __doc__        """ x.__ge__(y) <==> x>=y """        pass    def __gt__(self, y): # real signature unknown; restored from __doc__        """ x.__gt__(y) <==> x>y """        pass    def __iadd__(self, y): # real signature unknown; restored from __doc__        """ x.__iadd__(y) <==> x+=y """        pass    def __imul__(self, y): # real signature unknown; restored from __doc__        """ x.__imul__(y) <==> x*=y """        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_bytearray) -> mutable copy of bytes_or_bytearray.        bytearray(memory_view) -> bytearray.                Construct an mutable bytearray object from:          - an iterable yielding integers in range(256)          - a text string encoded using the specified encoding          - a bytes or a bytearray object          - any object implementing the buffer API.                bytearray(int) -> bytearray.                Construct a zero-initialized bytearray of the given length.        # (copied from class doc)        """        pass    def __iter__(self): # real signature unknown; restored from __doc__        """ x.__iter__() <==> iter(x) """        pass    def __len__(self): # real signature unknown; restored from __doc__        """ x.__len__() <==> len(x) """        pass    def __le__(self, y): # real signature unknown; restored from __doc__        """ x.__le__(y) <==> x<=y """        pass    def __lt__(self, y): # real signature unknown; restored from __doc__        """ x.__lt__(y) <==> x<y """        pass    def __mul__(self, n): # real signature unknown; restored from __doc__        """ x.__mul__(n) <==> x*n """        pass    @staticmethod # known case of __new__    def __new__(S, *more): # real signature unknown; restored from __doc__        """ T.__new__(S, ...) -> a new object with type S, a subtype of T """        pass    def __ne__(self, y): # real signature unknown; restored from __doc__        """ x.__ne__(y) <==> x!=y """        pass    def __reduce__(self, *args, **kwargs): # real signature unknown        """ Return state information for pickling. """        pass    def __repr__(self): # real signature unknown; restored from __doc__        """ x.__repr__() <==> repr(x) """        pass    def __rmul__(self, n): # real signature unknown; restored from __doc__        """ x.__rmul__(n) <==> n*x """        pass    def __setitem__(self, i, y): # real signature unknown; restored from __doc__        """ x.__setitem__(i, y) <==> x[i]=y """        pass    def __sizeof__(self): # real signature unknown; restored from __doc__        """        B.__sizeof__() -> int                 Returns the size of B in memory, in bytes        """        return 0    def __str__(self): # real signature unknown; restored from __doc__        """ x.__str__() <==> str(x) """        passclass str(basestring):    """    str(object=‘‘) -> string        Return a nice string representation of the object.    If the argument is a string, the return value is the same object.    """    def capitalize(self): # real signature unknown; restored from __doc__        """        S.capitalize() -> string                Return a copy of the string S with only its first character        capitalized.        """        return ""    def center(self, width, fillchar=None): # real signature unknown; restored from __doc__        """        S.center(width[, fillchar]) -> string                Return S centered in a string of length width. Padding is        done using the specified fill character (default is a space)        """        return ""    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 decode(self, encoding=None, errors=None): # real signature unknown; restored from __doc__        """        S.decode([encoding[,errors]]) -> object                Decodes S using the codec registered for encoding. encoding defaults        to the default encoding. errors may be given to set a different error        handling scheme. Default is ‘strict‘ meaning that encoding errors raise        a UnicodeDecodeError. Other possible values are ‘ignore‘ and ‘replace‘        as well as any other name registered with codecs.register_error that is        able to handle UnicodeDecodeErrors.        """        return object()    def encode(self, encoding=None, errors=None): # real signature unknown; restored from __doc__        """        S.encode([encoding[,errors]]) -> object                Encodes S using the codec registered for encoding. encoding defaults        to the default encoding. errors may be given to set a different error        handling scheme. 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 is able to handle UnicodeEncodeErrors.        """        return object()    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, tabsize=None): # real signature unknown; restored from __doc__        """        S.expandtabs([tabsize]) -> string                Return a copy of S where all tab characters are expanded using spaces.        If tabsize is not given, a tab size of 8 characters is assumed.        """        return ""    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(*args, **kwargs): # known special case of str.format        """        S.format(*args, **kwargs) -> string                Return a formatted version of S, using substitutions from args and kwargs.        The substitutions are identified by braces (‘{‘ and ‘}‘).        """        pass    def index(self, sub, start=None, end=None): # real signature unknown; restored from __doc__        """        S.index(sub [,start [,end]]) -> int                Like S.find() but raise ValueError when the substring is not found.        """        return 0    def isalnum(self): # real signature unknown; restored from __doc__        """        S.isalnum() -> bool                Return True if all characters in S are alphanumeric        and there is at least one character in S, False otherwise.        """        return False    def isalpha(self): # real signature unknown; restored from __doc__        """        S.isalpha() -> bool                Return True if all characters in S are alphabetic        and there is at least one character in S, False otherwise.        """        return False    def isdigit(self): # real signature unknown; restored from __doc__        """        S.isdigit() -> bool                Return True if all characters in S are digits        and there is at least one character in S, False otherwise.        """        return False    def islower(self): # real signature unknown; restored from __doc__        """        S.islower() -> bool                Return True if all cased characters in S are lowercase and there is        at least one cased character in S, False otherwise.        """        return False    def isspace(self): # real signature unknown; restored from __doc__        """        S.isspace() -> bool                Return True if all characters in S are whitespace        and there is at least one character in S, False otherwise.        """        return False    def istitle(self): # real signature unknown; restored from __doc__        """        S.istitle() -> bool                Return True if S is a titlecased string and there is at least one        character in S, 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__        """        S.isupper() -> bool                Return True if all cased characters in S are uppercase and there is        at least one cased character in S, False otherwise.        """        return False    def join(self, iterable): # real signature unknown; restored from __doc__        """        S.join(iterable) -> string                Return a string which is the concatenation of the strings in the        iterable.  The separator between elements is S.        """        return ""    def ljust(self, width, fillchar=None): # real signature unknown; restored from __doc__        """        S.ljust(width[, fillchar]) -> string                Return S left-justified in a string of length width. Padding is        done using the specified fill character (default is a space).        """        return ""    def lower(self): # real signature unknown; restored from __doc__        """        S.lower() -> string                Return a copy of the string S converted to lowercase.        """        return ""    def lstrip(self, chars=None): # real signature unknown; restored from __doc__        """        S.lstrip([chars]) -> string or unicode                Return a copy of the string S with leading whitespace removed.        If chars is given and not None, remove characters in chars instead.        If chars is unicode, S will be converted to unicode before stripping        """        return ""    def partition(self, sep): # real signature unknown; restored from __doc__        """        S.partition(sep) -> (head, sep, tail)                Search for the separator sep in S, and return the part before it,        the separator itself, and the part after it.  If the separator is not        found, return S and two empty strings.        """        pass    def replace(self, old, new, count=None): # real signature unknown; restored from __doc__        """        S.replace(old, new[, count]) -> string                Return a copy of string S with all occurrences of substring        old replaced by new.  If the optional argument count is        given, only the first count occurrences are replaced.        """        return ""    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                Like S.rfind() but raise ValueError when the substring is not found.        """        return 0    def rjust(self, width, fillchar=None): # real signature unknown; restored from __doc__        """        S.rjust(width[, fillchar]) -> string                Return S right-justified in a string of length width. Padding is        done using the specified fill character (default is a space)        """        return ""    def rpartition(self, sep): # real signature unknown; restored from __doc__        """        S.rpartition(sep) -> (head, sep, tail)                Search for the separator sep in S, starting at the end of S, and return        the part before it, the separator itself, and the part after it.  If the        separator is not found, return two empty strings and S.        """        pass    def rsplit(self, sep=None, maxsplit=None): # real signature unknown; restored from __doc__        """        S.rsplit([sep [,maxsplit]]) -> list of strings                Return a list of the words in the string S, using sep as the        delimiter string, starting at the end of the string and working        to the front.  If maxsplit is given, at most maxsplit splits are        done. If sep is not specified or is None, any whitespace string        is a separator.        """        return []    def rstrip(self, chars=None): # real signature unknown; restored from __doc__        """        S.rstrip([chars]) -> string or unicode                Return a copy of the string S with trailing whitespace removed.        If chars is given and not None, remove characters in chars instead.        If chars is unicode, S will be converted to unicode before stripping        """        return ""    def split(self, sep=None, maxsplit=None): # real signature unknown; restored from __doc__        """        S.split([sep [,maxsplit]]) -> list of strings                Return a list of the words in the string S, using sep as the        delimiter string.  If maxsplit is given, at most maxsplit        splits are done. If sep is not specified or is None, any        whitespace string is a separator and empty strings are removed        from the result.        """        return []    def splitlines(self, keepends=False): # real signature unknown; restored from __doc__        """        S.splitlines(keepends=False) -> list of strings                Return a list of the lines in S, breaking at line boundaries.        Line breaks are not included in the resulting list unless keepends        is given and true.        """        return []    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, chars=None): # real signature unknown; restored from __doc__        """        S.strip([chars]) -> string or unicode                Return a copy of the string S with leading and trailing        whitespace removed.        If chars is given and not None, remove characters in chars instead.        If chars is unicode, S will be converted to unicode before stripping        """        return ""    def swapcase(self): # real signature unknown; restored from __doc__        """        S.swapcase() -> string                Return a copy of the string S with uppercase characters        converted to lowercase and vice versa.        """        return ""    def title(self): # real signature unknown; restored from __doc__        """        S.title() -> string                Return a titlecased version of S, i.e. words start with uppercase        characters, all remaining cased characters have lowercase.        """        return ""    def translate(self, table, deletechars=None): # real signature unknown; restored from __doc__        """        S.translate(table [,deletechars]) -> string                Return a copy of the string S, where all characters occurring        in the optional argument deletechars are removed, and the        remaining characters have been mapped through the given        translation table, which must be a string of length 256 or None.        If the table argument is None, no translation is applied and        the operation simply removes the characters in deletechars.        """        return ""    def upper(self): # real signature unknown; restored from __doc__        """        S.upper() -> string                Return a copy of the string S converted to uppercase.        """        return ""    def zfill(self, width): # real signature unknown; restored from __doc__        """        S.zfill(width) -> string                Pad a numeric string S with zeros on the left, to fill a field        of the specified width.  The string S is never truncated.        """        return ""    def _formatter_field_name_split(self, *args, **kwargs): # real signature unknown        pass    def _formatter_parser(self, *args, **kwargs): # real signature unknown        pass    def __add__(self, y): # real signature unknown; restored from __doc__        """ x.__add__(y) <==> x+y """        pass    def __contains__(self, y): # real signature unknown; restored from __doc__        """ x.__contains__(y) <==> y in x """        pass    def __eq__(self, y): # real signature unknown; restored from __doc__        """ x.__eq__(y) <==> x==y """        pass    def __format__(self, format_spec): # real signature unknown; restored from __doc__        """        S.__format__(format_spec) -> string                Return a formatted version of S as described by format_spec.        """        return ""    def __getattribute__(self, name): # real signature unknown; restored from __doc__        """ x.__getattribute__(‘name‘) <==> x.name """        pass    def __getitem__(self, y): # real signature unknown; restored from __doc__        """ x.__getitem__(y) <==> x[y] """        pass    def __getnewargs__(self, *args, **kwargs): # real signature unknown        pass    def __getslice__(self, i, j): # real signature unknown; restored from __doc__        """        x.__getslice__(i, j) <==> x[i:j]                                      Use of negative indices is not supported.        """        pass    def __ge__(self, y): # real signature unknown; restored from __doc__        """ x.__ge__(y) <==> x>=y """        pass    def __gt__(self, y): # real signature unknown; restored from __doc__        """ x.__gt__(y) <==> x>y """        pass    def __hash__(self): # real signature unknown; restored from __doc__        """ x.__hash__() <==> hash(x) """        pass    def __init__(self, string=‘‘): # known special case of str.__init__        """        str(object=‘‘) -> string                Return a nice string representation of the object.        If the argument is a string, the return value is the same object.        # (copied from class doc)        """        pass    def __len__(self): # real signature unknown; restored from __doc__        """ x.__len__() <==> len(x) """        pass    def __le__(self, y): # real signature unknown; restored from __doc__        """ x.__le__(y) <==> x<=y """        pass    def __lt__(self, y): # real signature unknown; restored from __doc__        """ x.__lt__(y) <==> x<y """        pass    def __mod__(self, y): # real signature unknown; restored from __doc__        """ x.__mod__(y) <==> x%y """        pass    def __mul__(self, n): # real signature unknown; restored from __doc__        """ x.__mul__(n) <==> x*n """        pass    @staticmethod # known case of __new__    def __new__(S, *more): # real signature unknown; restored from __doc__        """ T.__new__(S, ...) -> a new object with type S, a subtype of T """        pass    def __ne__(self, y): # real signature unknown; restored from __doc__        """ x.__ne__(y) <==> x!=y """        pass    def __repr__(self): # real signature unknown; restored from __doc__        """ x.__repr__() <==> repr(x) """        pass    def __rmod__(self, y): # real signature unknown; restored from __doc__        """ x.__rmod__(y) <==> y%x """        pass    def __rmul__(self, n): # real signature unknown; restored from __doc__        """ x.__rmul__(n) <==> n*x """        pass    def __sizeof__(self): # real signature unknown; restored from __doc__        """ S.__sizeof__() -> size of S in memory, in bytes """        pass    def __str__(self): # real signature unknown; restored from __doc__        """ x.__str__() <==> str(x) """        passbytes = strclass 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:          def f(cls, arg1, arg2, ...): ...          f = classmethod(f)        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 __getattribute__(self, name): # real signature unknown; restored from __doc__        """ x.__getattribute__(‘name‘) <==> x.name """        pass    def __get__(self, obj, type=None): # real signature unknown; restored from __doc__        """ descr.__get__(obj[, type]) -> value """        pass    def __init__(self, function): # real signature unknown; restored from __doc__        pass    @staticmethod # known case of __new__    def __new__(S, *more): # real signature unknown; restored from __doc__        """ T.__new__(S, ...) -> a new object with type S, a subtype of T """        pass    __func__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # defaultclass complex(object):    """    complex(real[, imag]) -> complex number        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): # real signature unknown; restored from __doc__        """ x.__abs__() <==> abs(x) """        pass    def __add__(self, y): # real signature unknown; restored from __doc__        """ x.__add__(y) <==> x+y """        pass    def __coerce__(self, y): # real signature unknown; restored from __doc__        """ x.__coerce__(y) <==> coerce(x, y) """        pass    def __divmod__(self, y): # real signature unknown; restored from __doc__        """ x.__divmod__(y) <==> divmod(x, y) """        pass    def __div__(self, y): # real signature unknown; restored from __doc__        """ x.__div__(y) <==> x/y """        pass    def __eq__(self, y): # real signature unknown; restored from __doc__        """ x.__eq__(y) <==> x==y """        pass    def __float__(self): # real signature unknown; restored from __doc__        """ x.__float__() <==> float(x) """        pass    def __floordiv__(self, y): # real signature unknown; restored from __doc__        """ x.__floordiv__(y) <==> x//y """        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, name): # real signature unknown; restored from __doc__        """ x.__getattribute__(‘name‘) <==> x.name """        pass    def __getnewargs__(self, *args, **kwargs): # real signature unknown        pass    def __ge__(self, y): # real signature unknown; restored from __doc__        """ x.__ge__(y) <==> x>=y """        pass    def __gt__(self, y): # real signature unknown; restored from __doc__        """ x.__gt__(y) <==> x>y """        pass    def __hash__(self): # real signature unknown; restored from __doc__        """ x.__hash__() <==> hash(x) """        pass    def __init__(self, real, imag=None): # real signature unknown; restored from __doc__        pass    def __int__(self): # real signature unknown; restored from __doc__        """ x.__int__() <==> int(x) """        pass    def __le__(self, y): # real signature unknown; restored from __doc__        """ x.__le__(y) <==> x<=y """        pass    def __long__(self): # real signature unknown; restored from __doc__        """ x.__long__() <==> long(x) """        pass    def __lt__(self, y): # real signature unknown; restored from __doc__        """ x.__lt__(y) <==> x<y """        pass    def __mod__(self, y): # real signature unknown; restored from __doc__        """ x.__mod__(y) <==> x%y """        pass    def __mul__(self, y): # real signature unknown; restored from __doc__        """ x.__mul__(y) <==> x*y """        pass    def __neg__(self): # real signature unknown; restored from __doc__        """ x.__neg__() <==> -x """        pass    @staticmethod # known case of __new__    def __new__(S, *more): # real signature unknown; restored from __doc__        """ T.__new__(S, ...) -> a new object with type S, a subtype of T """        pass    def __ne__(self, y): # real signature unknown; restored from __doc__        """ x.__ne__(y) <==> x!=y """        pass    def __nonzero__(self): # real signature unknown; restored from __doc__        """ x.__nonzero__() <==> x != 0 """        pass    def __pos__(self): # real signature unknown; restored from __doc__        """ x.__pos__() <==> +x """        pass    def __pow__(self, y, z=None): # real signature unknown; restored from __doc__        """ x.__pow__(y[, z]) <==> pow(x, y[, z]) """        pass    def __radd__(self, y): # real signature unknown; restored from __doc__        """ x.__radd__(y) <==> y+x """        pass    def __rdivmod__(self, y): # real signature unknown; restored from __doc__        """ x.__rdivmod__(y) <==> divmod(y, x) """        pass    def __rdiv__(self, y): # real signature unknown; restored from __doc__        """ x.__rdiv__(y) <==> y/x """        pass    def __repr__(self): # real signature unknown; restored from __doc__        """ x.__repr__() <==> repr(x) """        pass    def __rfloordiv__(self, y): # real signature unknown; restored from __doc__        """ x.__rfloordiv__(y) <==> y//x """        pass    def __rmod__(self, y): # real signature unknown; restored from __doc__        """ x.__rmod__(y) <==> y%x """        pass    def __rmul__(self, y): # real signature unknown; restored from __doc__        """ x.__rmul__(y) <==> y*x """        pass    def __rpow__(self, x, z=None): # real signature unknown; restored from __doc__        """ y.__rpow__(x[, z]) <==> pow(x, y[, z]) """        pass    def __rsub__(self, y): # real signature unknown; restored from __doc__        """ x.__rsub__(y) <==> y-x """        pass    def __rtruediv__(self, y): # real signature unknown; restored from __doc__        """ x.__rtruediv__(y) <==> y/x """        pass    def __str__(self): # real signature unknown; restored from __doc__        """ x.__str__() <==> str(x) """        pass    def __sub__(self, y): # real signature unknown; restored from __doc__        """ x.__sub__(y) <==> x-y """        pass    def __truediv__(self, y): # real signature unknown; restored from __doc__        """ x.__truediv__(y) <==> x/y """        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 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(S, v=None): # real signature unknown; restored from __doc__        """        dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.        v defaults to None.        """        pass    def get(self, k, d=None): # real signature unknown; restored from __doc__        """ D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None. """        pass    def has_key(self, k): # real signature unknown; restored from __doc__        """ D.has_key(k) -> True if D has a key k, else False """        return False    def items(self): # real signature unknown; restored from __doc__        """ D.items() -> list of D‘s (key, value) pairs, as 2-tuples """        return []    def iteritems(self): # real signature unknown; restored from __doc__        """ D.iteritems() -> an iterator over the (key, value) items of D """        pass    def iterkeys(self): # real signature unknown; restored from __doc__        """ D.iterkeys() -> an iterator over the keys of D """        pass    def itervalues(self): # real signature unknown; restored from __doc__        """ D.itervalues() -> an iterator over the values of D """        pass    def keys(self): # real signature unknown; restored from __doc__        """ D.keys() -> list of D‘s keys """        return []    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, k, d=None): # real signature unknown; restored from __doc__        """ D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D """        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 present and has a .keys() method, does:     for k in E: D[k] = E[k]        If E present and lacks .keys() method, 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() -> list of D‘s values """        return []    def viewitems(self): # real signature unknown; restored from __doc__        """ D.viewitems() -> a set-like object providing a view on D‘s items """        pass    def viewkeys(self): # real signature unknown; restored from __doc__        """ D.viewkeys() -> a set-like object providing a view on D‘s keys """        pass    def viewvalues(self): # real signature unknown; restored from __doc__        """ D.viewvalues() -> an object providing a view on D‘s values """        pass    def __cmp__(self, y): # real signature unknown; restored from __doc__        """ x.__cmp__(y) <==> cmp(x,y) """        pass    def __contains__(self, k): # real signature unknown; restored from __doc__        """ D.__contains__(k) -> True if D has a key k, else False """        return False    def __delitem__(self, y): # real signature unknown; restored from __doc__        """ x.__delitem__(y) <==> del x[y] """        pass    def __eq__(self, y): # real signature unknown; restored from __doc__        """ x.__eq__(y) <==> x==y """        pass    def __getattribute__(self, name): # real signature unknown; restored from __doc__        """ x.__getattribute__(‘name‘) <==> x.name """        pass    def __getitem__(self, y): # real signature unknown; restored from __doc__        """ x.__getitem__(y) <==> x[y] """        pass    def __ge__(self, y): # real signature unknown; restored from __doc__        """ x.__ge__(y) <==> x>=y """        pass    def __gt__(self, y): # real signature unknown; restored from __doc__        """ x.__gt__(y) <==> x>y """        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): # real signature unknown; restored from __doc__        """ x.__iter__() <==> iter(x) """        pass    def __len__(self): # real signature unknown; restored from __doc__        """ x.__len__() <==> len(x) """        pass    def __le__(self, y): # real signature unknown; restored from __doc__        """ x.__le__(y) <==> x<=y """        pass    def __lt__(self, y): # real signature unknown; restored from __doc__        """ x.__lt__(y) <==> x<y """        pass    @staticmethod # known case of __new__    def __new__(S, *more): # real signature unknown; restored from __doc__        """ T.__new__(S, ...) -> a new object with type S, a subtype of T """        pass    def __ne__(self, y): # real signature unknown; restored from __doc__        """ x.__ne__(y) <==> x!=y """        pass    def __repr__(self): # real signature unknown; restored from __doc__        """ x.__repr__() <==> repr(x) """        pass    def __setitem__(self, i, y): # real signature unknown; restored from __doc__        """ x.__setitem__(i, y) <==> x[i]=y """        pass    def __sizeof__(self): # real signature unknown; restored from __doc__        """ D.__sizeof__() -> size of D in memory, in bytes """        pass    __hash__ = Noneclass enumerate(object):    """    enumerate(iterable[, start]) -> iterator for index, value of iterable        Return an enumerate object.  iterable must be another object that supports    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 next(self): # real signature unknown; restored from __doc__        """ x.next() -> the next value, or raise StopIteration """        pass    def __getattribute__(self, name): # real signature unknown; restored from __doc__        """ x.__getattribute__(‘name‘) <==> x.name """        pass    def __init__(self, iterable, start=0): # known special case of enumerate.__init__        """ x.__init__(...) initializes x; see help(type(x)) for signature """        pass    def __iter__(self): # real signature unknown; restored from __doc__        """ x.__iter__() <==> iter(x) """        pass    @staticmethod # known case of __new__    def __new__(S, *more): # real signature unknown; restored from __doc__        """ T.__new__(S, ...) -> a new object with type S, a subtype of T """        passclass file(object):    """    file(name[, mode[, buffering]]) -> file object        Open a file.  The mode can be ‘r‘, ‘w‘ or ‘a‘ for reading (default),    writing or appending.  The file will be created if it doesn‘t exist    when opened for writing or appending; it will be truncated when    opened for writing.  Add a ‘b‘ to the mode for binary files.    Add a ‘+‘ to the mode to allow simultaneous reading and writing.    If the buffering argument is given, 0 means unbuffered, 1 means line    buffered, and larger numbers specify the buffer size.  The preferred way    to open a file is with the builtin open() function.    Add a ‘U‘ to mode to open the file for input with universal newline    support.  Any line ending in the input file will be seen as a ‘\n‘    in Python.  Also, a file so opened gains the attribute ‘newlines‘;    the value for this attribute is one of None (no newline read yet),    ‘\r‘, ‘\n‘, ‘\r\n‘ or a tuple containing all the newline types seen.        ‘U‘ cannot be combined with ‘w‘ or ‘+‘ mode.    """    def close(self): # real signature unknown; restored from __doc__        """        close() -> None or (perhaps) an integer.  Close the file.                Sets data attribute .closed to True.  A closed file cannot be used for        further I/O operations.  close() may be called more than once without        error.  Some kinds of file objects (for example, opened by popen())        may return an exit status upon closing.        """        pass    def fileno(self): # real signature unknown; restored from __doc__        """        fileno() -> integer "file descriptor".                This is needed for lower-level file interfaces, such os.read().        """        return 0    def flush(self): # real signature unknown; restored from __doc__        """ flush() -> None.  Flush the internal I/O buffer. """        pass    def isatty(self): # real signature unknown; restored from __doc__        """ isatty() -> true or false.  True if the file is connected to a tty device. """        return False    def next(self): # real signature unknown; restored from __doc__        """ x.next() -> the next value, or raise StopIteration """        pass    def read(self, size=None): # real signature unknown; restored from __doc__        """        read([size]) -> read at most size bytes, returned as a string.                If the size argument is negative or omitted, read until EOF is reached.        Notice that when in non-blocking mode, less data than what was requested        may be returned, even if no size parameter was given.        """        pass    def readinto(self): # real signature unknown; restored from __doc__        """ readinto() -> Undocumented.  Don‘t use this; it may go away. """        pass    def readline(self, size=None): # real signature unknown; restored from __doc__        """        readline([size]) -> next line from the file, as a string.                Retain newline.  A non-negative size argument limits the maximum        number of bytes to return (an incomplete line may be returned then).        Return an empty string at EOF.        """        pass    def readlines(self, size=None): # real signature unknown; restored from __doc__        """        readlines([size]) -> list of strings, each a line from the file.                Call readline() repeatedly and return a list of the lines so read.        The optional size argument, if given, is an approximate bound on the        total number of bytes in the lines returned.        """        return []    def seek(self, offset, whence=None): # real signature unknown; restored from __doc__        """        seek(offset[, whence]) -> None.  Move to new file position.                Argument offset is a byte count.  Optional argument whence defaults to        0 (offset from start of file, offset should be >= 0); other values are 1        (move relative to current position, positive or negative), and 2 (move        relative to end of file, usually negative, although many platforms allow        seeking beyond the end of a file).  If the file is opened in text mode,        only offsets returned by tell() are legal.  Use of other offsets causes        undefined behavior.        Note that not all file objects are seekable.        """        pass    def tell(self): # real signature unknown; restored from __doc__        """ tell() -> current file position, an integer (may be a long integer). """        pass    def truncate(self, size=None): # real signature unknown; restored from __doc__        """        truncate([size]) -> None.  Truncate the file to at most size bytes.                Size defaults to the current file position, as returned by tell().        """        pass    def write(self, p_str): # real signature unknown; restored from __doc__        """        write(str) -> None.  Write string str to file.                Note that due to buffering, flush() or close() may be needed before        the file on disk reflects the data written.        """        pass    def writelines(self, sequence_of_strings): # real signature unknown; restored from __doc__        """        writelines(sequence_of_strings) -> None.  Write the strings to the file.                Note that newlines are not added.  The sequence can be any iterable object        producing strings. This is equivalent to calling write() for each string.        """        pass    def xreadlines(self): # real signature unknown; restored from __doc__        """        xreadlines() -> returns self.                For backward compatibility. File objects now include the performance        optimizations previously implemented in the xreadlines module.        """        pass    def __delattr__(self, name): # real signature unknown; restored from __doc__        """ x.__delattr__(‘name‘) <==> del x.name """        pass    def __enter__(self): # real signature unknown; restored from __doc__        """ __enter__() -> self. """        return self    def __exit__(self, *excinfo): # real signature unknown; restored from __doc__        """ __exit__(*excinfo) -> None.  Closes the file. """        pass    def __getattribute__(self, name): # real signature unknown; restored from __doc__        """ x.__getattribute__(‘name‘) <==> x.name """        pass    def __init__(self, name, mode=None, buffering=None): # real signature unknown; restored from __doc__        pass    def __iter__(self): # real signature unknown; restored from __doc__        """ x.__iter__() <==> iter(x) """        pass    @staticmethod # known case of __new__    def __new__(S, *more): # real signature unknown; restored from __doc__        """ T.__new__(S, ...) -> a new object with type S, a subtype of T """        pass    def __repr__(self): # real signature unknown; restored from __doc__        """ x.__repr__() <==> repr(x) """        pass    def __setattr__(self, name, value): # real signature unknown; restored from __doc__        """ x.__setattr__(‘name‘, value) <==> x.name = value """        pass    closed = property(lambda self: True)    """True if the file is closed    :type: bool    """    encoding = property(lambda self: ‘‘)    """file encoding    :type: string    """    errors = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default    """Unicode error handler"""    mode = property(lambda self: ‘‘)    """file mode (‘r‘, ‘U‘, ‘w‘, ‘a‘, possibly with ‘b‘ or ‘+‘ added)    :type: string    """    name = property(lambda self: ‘‘)    """file name    :type: string    """    newlines = property(lambda self: ‘‘)    """end-of-line convention used in this file    :type: string    """    softspace = property(lambda self: True)    """flag indicating that a space needs to be printed; used by print    :type: bool    """class float(object):    """    float(x) -> floating point number        Convert a string or number to a floating point number, if possible.    """    def as_integer_ratio(self): # real signature unknown; restored from __doc__        """        float.as_integer_ratio() -> (int, int)                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    def fromhex(self, string): # real signature unknown; restored from __doc__        """        float.fromhex(string) -> float                Create a floating-point number from a hexadecimal string.        >>> float.fromhex(‘0x1.ffffp10‘)        2047.984375        >>> float.fromhex(‘-0x1p-1074‘)        -4.9406564584124654e-324        """        return 0.0    def hex(self): # real signature unknown; restored from __doc__        """        float.hex() -> string                Return a hexadecimal representation of a floating-point number.        >>> (-0.1).hex()        ‘-0x1.999999999999ap-4‘        >>> 3.14159.hex()        ‘0x1.921f9f01b866ep+1‘        """        return ""    def is_integer(self, *args, **kwargs): # real signature unknown        """ Return True if the float is an integer. """        pass    def __abs__(self): # real signature unknown; restored from __doc__        """ x.__abs__() <==> abs(x) """        pass    def __add__(self, y): # real signature unknown; restored from __doc__        """ x.__add__(y) <==> x+y """        pass    def __coerce__(self, y): # real signature unknown; restored from __doc__        """ x.__coerce__(y) <==> coerce(x, y) """        pass    def __divmod__(self, y): # real signature unknown; restored from __doc__        """ x.__divmod__(y) <==> divmod(x, y) """        pass    def __div__(self, y): # real signature unknown; restored from __doc__        """ x.__div__(y) <==> x/y """        pass    def __eq__(self, y): # real signature unknown; restored from __doc__        """ x.__eq__(y) <==> x==y """        pass    def __float__(self): # real signature unknown; restored from __doc__        """ x.__float__() <==> float(x) """        pass    def __floordiv__(self, y): # real signature unknown; restored from __doc__        """ x.__floordiv__(y) <==> x//y """        pass    def __format__(self, format_spec): # real signature unknown; restored from __doc__        """        float.__format__(format_spec) -> string                Formats the float according to format_spec.        """        return ""    def __getattribute__(self, name): # real signature unknown; restored from __doc__        """ x.__getattribute__(‘name‘) <==> x.name """        pass    def __getformat__(self, typestr): # real signature unknown; restored from __doc__        """        float.__getformat__(typestr) -> string                You probably don‘t want to use this function.  It exists mainly to be        used in Python‘s test suite.                typestr must be ‘double‘ or ‘float‘.  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.        """        return ""    def __getnewargs__(self, *args, **kwargs): # real signature unknown        pass    def __ge__(self, y): # real signature unknown; restored from __doc__        """ x.__ge__(y) <==> x>=y """        pass    def __gt__(self, y): # real signature unknown; restored from __doc__        """ x.__gt__(y) <==> x>y """        pass    def __hash__(self): # real signature unknown; restored from __doc__        """ x.__hash__() <==> hash(x) """        pass    def __init__(self, x): # real signature unknown; restored from __doc__        pass    def __int__(self): # real signature unknown; restored from __doc__        """ x.__int__() <==> int(x) """        pass    def __le__(self, y): # real signature unknown; restored from __doc__        """ x.__le__(y) <==> x<=y """        pass    def __long__(self): # real signature unknown; restored from __doc__        """ x.__long__() <==> long(x) """        pass    def __lt__(self, y): # real signature unknown; restored from __doc__        """ x.__lt__(y) <==> x<y """        pass    def __mod__(self, y): # real signature unknown; restored from __doc__        """ x.__mod__(y) <==> x%y """        pass    def __mul__(self, y): # real signature unknown; restored from __doc__        """ x.__mul__(y) <==> x*y """        pass    def __neg__(self): # real signature unknown; restored from __doc__        """ x.__neg__() <==> -x """        pass    @staticmethod # known case of __new__    def __new__(S, *more): # real signature unknown; restored from __doc__        """ T.__new__(S, ...) -> a new object with type S, a subtype of T """        pass    def __ne__(self, y): # real signature unknown; restored from __doc__        """ x.__ne__(y) <==> x!=y """        pass    def __nonzero__(self): # real signature unknown; restored from __doc__        """ x.__nonzero__() <==> x != 0 """        pass    def __pos__(self): # real signature unknown; restored from __doc__        """ x.__pos__() <==> +x """        pass    def __pow__(self, y, z=None): # real signature unknown; restored from __doc__        """ x.__pow__(y[, z]) <==> pow(x, y[, z]) """        pass    def __radd__(self, y): # real signature unknown; restored from __doc__        """ x.__radd__(y) <==> y+x """        pass    def __rdivmod__(self, y): # real signature unknown; restored from __doc__        """ x.__rdivmod__(y) <==> divmod(y, x) """        pass    def __rdiv__(self, y): # real signature unknown; restored from __doc__        """ x.__rdiv__(y) <==> y/x """        pass    def __repr__(self): # real signature unknown; restored from __doc__        """ x.__repr__() <==> repr(x) """        pass    def __rfloordiv__(self, y): # real signature unknown; restored from __doc__        """ x.__rfloordiv__(y) <==> y//x """        pass    def __rmod__(self, y): # real signature unknown; restored from __doc__        """ x.__rmod__(y) <==> y%x """        pass    def __rmul__(self, y): # real signature unknown; restored from __doc__        """ x.__rmul__(y) <==> y*x """        pass    def __rpow__(self, x, z=None): # real signature unknown; restored from __doc__        """ y.__rpow__(x[, z]) <==> pow(x, y[, z]) """        pass    def __rsub__(self, y): # real signature unknown; restored from __doc__        """ x.__rsub__(y) <==> y-x """        pass    def __rtruediv__(self, y): # real signature unknown; restored from __doc__        """ x.__rtruediv__(y) <==> y/x """        pass    def __setformat__(self, typestr, fmt): # real signature unknown; restored from __doc__        """        float.__setformat__(typestr, fmt) -> None                You probably don‘t want to use this function.  It exists mainly to be        used in Python‘s test suite.                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.                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): # real signature unknown; restored from __doc__        """ x.__str__() <==> str(x) """        pass    def __sub__(self, y): # real signature unknown; restored from __doc__        """ x.__sub__(y) <==> x-y """        pass    def __truediv__(self, y): # real signature unknown; restored from __doc__        """ x.__truediv__(y) <==> x/y """        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 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 or more sets as a new set.                (i.e. elements that are common to all of the 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, y): # real signature unknown; restored from __doc__        """ x.__and__(y) <==> x&y """        pass    def __cmp__(self, y): # real signature unknown; restored from __doc__        """ x.__cmp__(y) <==> cmp(x,y) """        pass    def __contains__(self, y): # real signature unknown; restored from __doc__        """ x.__contains__(y) <==> y in x. """        pass    def __eq__(self, y): # real signature unknown; restored from __doc__        """ x.__eq__(y) <==> x==y """        pass    def __getattribute__(self, name): # real signature unknown; restored from __doc__        """ x.__getattribute__(‘name‘) <==> x.name """        pass    def __ge__(self, y): # real signature unknown; restored from __doc__        """ x.__ge__(y) <==> x>=y """        pass    def __gt__(self, y): # real signature unknown; restored from __doc__        """ x.__gt__(y) <==> x>y """        pass    def __hash__(self): # real signature unknown; restored from __doc__        """ x.__hash__() <==> hash(x) """        pass    def __init__(self, seq=()): # known special case of frozenset.__init__        """ x.__init__(...) initializes x; see help(type(x)) for signature """        pass    def __iter__(self): # real signature unknown; restored from __doc__        """ x.__iter__() <==> iter(x) """        pass    def __len__(self): # real signature unknown; restored from __doc__        """ x.__len__() <==> len(x) """        pass    def __le__(self, y): # real signature unknown; restored from __doc__        """ x.__le__(y) <==> x<=y """        pass    def __lt__(self, y): # real signature unknown; restored from __doc__        """ x.__lt__(y) <==> x<y """        pass    @staticmethod # known case of __new__    def __new__(S, *more): # real signature unknown; restored from __doc__        """ T.__new__(S, ...) -> a new object with type S, a subtype of T """        pass    def __ne__(self, y): # real signature unknown; restored from __doc__        """ x.__ne__(y) <==> x!=y """        pass    def __or__(self, y): # real signature unknown; restored from __doc__        """ x.__or__(y) <==> x|y """        pass    def __rand__(self, y): # real signature unknown; restored from __doc__        """ x.__rand__(y) <==> y&x """        pass    def __reduce__(self, *args, **kwargs): # real signature unknown        """ Return state information for pickling. """        pass    def __repr__(self): # real signature unknown; restored from __doc__        """ x.__repr__() <==> repr(x) """        pass    def __ror__(self, y): # real signature unknown; restored from __doc__        """ x.__ror__(y) <==> y|x """        pass    def __rsub__(self, y): # real signature unknown; restored from __doc__        """ x.__rsub__(y) <==> y-x """        pass    def __rxor__(self, y): # real signature unknown; restored from __doc__        """ x.__rxor__(y) <==> y^x """        pass    def __sizeof__(self): # real signature unknown; restored from __doc__        """ S.__sizeof__() -> size of S in memory, in bytes """        pass    def __sub__(self, y): # real signature unknown; restored from __doc__        """ x.__sub__(y) <==> x-y """        pass    def __xor__(self, y): # real signature unknown; restored from __doc__        """ x.__xor__(y) <==> x^y """        passclass list(object):    """    list() -> new empty list    list(iterable) -> new list initialized from iterable‘s items    """    def append(self, p_object): # real signature unknown; restored from __doc__        """ L.append(object) -- append object to end """        pass    def count(self, value): # real signature unknown; restored from __doc__        """ L.count(value) -> integer -- return number of occurrences of value """        return 0    def extend(self, iterable): # real signature unknown; restored from __doc__        """ L.extend(iterable) -- extend list by appending elements from the iterable """        pass    def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__        """        L.index(value, [start, [stop]]) -> integer -- return first index of value.        Raises ValueError if the value is not present.        """        return 0    def insert(self, index, p_object): # real signature unknown; restored from __doc__        """ L.insert(index, object) -- insert object before index """        pass    def pop(self, index=None): # real signature unknown; restored from __doc__        """        L.pop([index]) -> item -- remove and return item at index (default last).        Raises IndexError if list is empty or index is out of range.        """        pass    def remove(self, value): # real signature unknown; restored from __doc__        """        L.remove(value) -- remove first occurrence of value.        Raises ValueError if the value is not present.        """        pass    def reverse(self): # real signature unknown; restored from __doc__        """ L.reverse() -- reverse *IN PLACE* """        pass    def sort(self, cmp=None, key=None, reverse=False): # real signature unknown; restored from __doc__        """        L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;        cmp(x, y) -> -1, 0, 1        """        pass    def __add__(self, y): # real signature unknown; restored from __doc__        """ x.__add__(y) <==> x+y """        pass    def __contains__(self, y): # real signature unknown; restored from __doc__        """ x.__contains__(y) <==> y in x """        pass    def __delitem__(self, y): # real signature unknown; restored from __doc__        """ x.__delitem__(y) <==> del x[y] """        pass    def __delslice__(self, i, j): # real signature unknown; restored from __doc__        """        x.__delslice__(i, j) <==> del x[i:j]                                      Use of negative indices is not supported.        """        pass    def __eq__(self, y): # real signature unknown; restored from __doc__        """ x.__eq__(y) <==> x==y """        pass    def __getattribute__(self, name): # real signature unknown; restored from __doc__        """ x.__getattribute__(‘name‘) <==> x.name """        pass    def __getitem__(self, y): # real signature unknown; restored from __doc__        """ x.__getitem__(y) <==> x[y] """        pass    def __getslice__(self, i, j): # real signature unknown; restored from __doc__        """        x.__getslice__(i, j) <==> x[i:j]                                      Use of negative indices is not supported.        """        pass    def __ge__(self, y): # real signature unknown; restored from __doc__        """ x.__ge__(y) <==> x>=y """        pass    def __gt__(self, y): # real signature unknown; restored from __doc__        """ x.__gt__(y) <==> x>y """        pass    def __iadd__(self, y): # real signature unknown; restored from __doc__        """ x.__iadd__(y) <==> x+=y """        pass    def __imul__(self, y): # real signature unknown; restored from __doc__        """ x.__imul__(y) <==> x*=y """        pass    def __init__(self, seq=()): # known special case of list.__init__        """        list() -> new empty list        list(iterable) -> new list initialized from iterable‘s items        # (copied from class doc)        """        pass    def __iter__(self): # real signature unknown; restored from __doc__        """ x.__iter__() <==> iter(x) """        pass    def __len__(self): # real signature unknown; restored from __doc__        """ x.__len__() <==> len(x) """        pass    def __le__(self, y): # real signature unknown; restored from __doc__        """ x.__le__(y) <==> x<=y """        pass    def __lt__(self, y): # real signature unknown; restored from __doc__        """ x.__lt__(y) <==> x<y """        pass    def __mul__(self, n): # real signature unknown; restored from __doc__        """ x.__mul__(n) <==> x*n """        pass    @staticmethod # known case of __new__    def __new__(S, *more): # real signature unknown; restored from __doc__        """ T.__new__(S, ...) -> a new object with type S, a subtype of T """        pass    def __ne__(self, y): # real signature unknown; restored from __doc__        """ x.__ne__(y) <==> x!=y """        pass    def __repr__(self): # real signature unknown; restored from __doc__        """ x.__repr__() <==> repr(x) """        pass    def __reversed__(self): # real signature unknown; restored from __doc__        """ L.__reversed__() -- return a reverse iterator over the list """        pass    def __rmul__(self, n): # real signature unknown; restored from __doc__        """ x.__rmul__(n) <==> n*x """        pass    def __setitem__(self, i, y): # real signature unknown; restored from __doc__        """ x.__setitem__(i, y) <==> x[i]=y """        pass    def __setslice__(self, i, j, y): # real signature unknown; restored from __doc__        """        x.__setslice__(i, j, y) <==> x[i:j]=y                                      Use  of negative indices is not supported.        """        pass    def __sizeof__(self): # real signature unknown; restored from __doc__        """ L.__sizeof__() -- size of L in memory, in bytes """        pass    __hash__ = Noneclass long(object):    """    long(x=0) -> long    long(x, base=10) -> long        Convert a number or string to a long integer, or return 0L if no arguments    are given.  If x is floating point, the conversion truncates towards zero.        If x is not a number or if base is given, then x must be a string or    Unicode object 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)    4L    """    def bit_length(self): # real signature unknown; restored from __doc__        """        long.bit_length() -> int or long                Number of bits necessary to represent self in binary.        >>> bin(37L)        ‘0b100101‘        >>> (37L).bit_length()        6        """        return 0    def conjugate(self, *args, **kwargs): # real signature unknown        """ Returns self, the complex conjugate of any long. """        pass    def __abs__(self): # real signature unknown; restored from __doc__        """ x.__abs__() <==> abs(x) """        pass    def __add__(self, y): # real signature unknown; restored from __doc__        """ x.__add__(y) <==> x+y """        pass    def __and__(self, y): # real signature unknown; restored from __doc__        """ x.__and__(y) <==> x&y """        pass    def __cmp__(self, y): # real signature unknown; restored from __doc__        """ x.__cmp__(y) <==> cmp(x,y) """        pass    def __coerce__(self, y): # real signature unknown; restored from __doc__        """ x.__coerce__(y) <==> coerce(x, y) """        pass    def __divmod__(self, y): # real signature unknown; restored from __doc__        """ x.__divmod__(y) <==> divmod(x, y) """        pass    def __div__(self, y): # real signature unknown; restored from __doc__        """ x.__div__(y) <==> x/y """        pass    def __float__(self): # real signature unknown; restored from __doc__        """ x.__float__() <==> float(x) """        pass    def __floordiv__(self, y): # real signature unknown; restored from __doc__        """ x.__floordiv__(y) <==> x//y """        pass    def __format__(self, *args, **kwargs): # real signature unknown        pass    def __getattribute__(self, name): # real signature unknown; restored from __doc__        """ x.__getattribute__(‘name‘) <==> x.name """        pass    def __getnewargs__(self, *args, **kwargs): # real signature unknown        pass    def __hash__(self): # real signature unknown; restored from __doc__        """ x.__hash__() <==> hash(x) """        pass    def __hex__(self): # real signature unknown; restored from __doc__        """ x.__hex__() <==> hex(x) """        pass    def __index__(self): # real signature unknown; restored from __doc__        """ x[y:z] <==> x[y.__index__():z.__index__()] """        pass    def __init__(self, x=0): # real signature unknown; restored from __doc__        pass    def __int__(self): # real signature unknown; restored from __doc__        """ x.__int__() <==> int(x) """        pass    def __invert__(self): # real signature unknown; restored from __doc__        """ x.__invert__() <==> ~x """        pass    def __long__(self): # real signature unknown; restored from __doc__        """ x.__long__() <==> long(x) """        pass    def __lshift__(self, y): # real signature unknown; restored from __doc__        """ x.__lshift__(y) <==> x<<y """        pass    def __mod__(self, y): # real signature unknown; restored from __doc__        """ x.__mod__(y) <==> x%y """        pass    def __mul__(self, y): # real signature unknown; restored from __doc__        """ x.__mul__(y) <==> x*y """        pass    def __neg__(self): # real signature unknown; restored from __doc__        """ x.__neg__() <==> -x """        pass    @staticmethod # known case of __new__    def __new__(S, *more): # real signature unknown; restored from __doc__        """ T.__new__(S, ...) -> a new object with type S, a subtype of T """        pass    def __nonzero__(self): # real signature unknown; restored from __doc__        """ x.__nonzero__() <==> x != 0 """        pass    def __oct__(self): # real signature unknown; restored from __doc__        """ x.__oct__() <==> oct(x) """        pass    def __or__(self, y): # real signature unknown; restored from __doc__        """ x.__or__(y) <==> x|y """        pass    def __pos__(self): # real signature unknown; restored from __doc__        """ x.__pos__() <==> +x """        pass    def __pow__(self, y, z=None): # real signature unknown; restored from __doc__        """ x.__pow__(y[, z]) <==> pow(x, y[, z]) """        pass    def __radd__(self, y): # real signature unknown; restored from __doc__        """ x.__radd__(y) <==> y+x """        pass    def __rand__(self, y): # real signature unknown; restored from __doc__        """ x.__rand__(y) <==> y&x """        pass    def __rdivmod__(self, y): # real signature unknown; restored from __doc__        """ x.__rdivmod__(y) <==> divmod(y, x) """        pass    def __rdiv__(self, y): # real signature unknown; restored from __doc__        """ x.__rdiv__(y) <==> y/x """        pass    def __repr__(self): # real signature unknown; restored from __doc__        """ x.__repr__() <==> repr(x) """        pass    def __rfloordiv__(self, y): # real signature unknown; restored from __doc__        """ x.__rfloordiv__(y) <==> y//x """        pass    def __rlshift__(self, y): # real signature unknown; restored from __doc__        """ x.__rlshift__(y) <==> y<<x """        pass    def __rmod__(self, y): # real signature unknown; restored from __doc__        """ x.__rmod__(y) <==> y%x """        pass    def __rmul__(self, y): # real signature unknown; restored from __doc__        """ x.__rmul__(y) <==> y*x """        pass    def __ror__(self, y): # real signature unknown; restored from __doc__        """ x.__ror__(y) <==> y|x """        pass    def __rpow__(self, x, z=None): # real signature unknown; restored from __doc__        """ y.__rpow__(x[, z]) <==> pow(x, y[, z]) """        pass    def __rrshift__(self, y): # real signature unknown; restored from __doc__        """ x.__rrshift__(y) <==> y>>x """        pass    def __rshift__(self, y): # real signature unknown; restored from __doc__        """ x.__rshift__(y) <==> x>>y """        pass    def __rsub__(self, y): # real signature unknown; restored from __doc__        """ x.__rsub__(y) <==> y-x """        pass    def __rtruediv__(self, y): # real signature unknown; restored from __doc__        """ x.__rtruediv__(y) <==> y/x """        pass    def __rxor__(self, y): # real signature unknown; restored from __doc__        """ x.__rxor__(y) <==> y^x """        pass    def __sizeof__(self, *args, **kwargs): # real signature unknown        """ Returns size in memory, in bytes """        pass    def __str__(self): # real signature unknown; restored from __doc__        """ x.__str__() <==> str(x) """        pass    def __sub__(self, y): # real signature unknown; restored from __doc__        """ x.__sub__(y) <==> x-y """        pass    def __truediv__(self, y): # real signature unknown; restored from __doc__        """ x.__truediv__(y) <==> x/y """        pass    def __trunc__(self, *args, **kwargs): # real signature unknown        """ Truncating an Integral returns itself. """        pass    def __xor__(self, y): # real signature unknown; restored from __doc__        """ x.__xor__(y) <==> x^y """        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 memoryview(object):    """    memoryview(object)        Create a new memoryview object which references the given object.    """    def tobytes(self, *args, **kwargs): # real signature unknown        pass    def tolist(self, *args, **kwargs): # real signature unknown        pass    def __delitem__(self, y): # real signature unknown; restored from __doc__        """ x.__delitem__(y) <==> del x[y] """        pass    def __eq__(self, y): # real signature unknown; restored from __doc__        """ x.__eq__(y) <==> x==y """        pass    def __getattribute__(self, name): # real signature unknown; restored from __doc__        """ x.__getattribute__(‘name‘) <==> x.name """        pass    def __getitem__(self, y): # real signature unknown; restored from __doc__        """ x.__getitem__(y) <==> x[y] """        pass    def __ge__(self, y): # real signature unknown; restored from __doc__        """ x.__ge__(y) <==> x>=y """        pass    def __gt__(self, y): # real signature unknown; restored from __doc__        """ x.__gt__(y) <==> x>y """        pass    def __init__(self, p_object): # real signature unknown; restored from __doc__        pass    def __len__(self): # real signature unknown; restored from __doc__        """ x.__len__() <==> len(x) """        pass    def __le__(self, y): # real signature unknown; restored from __doc__        """ x.__le__(y) <==> x<=y """        pass    def __lt__(self, y): # real signature unknown; restored from __doc__        """ x.__lt__(y) <==> x<y """        pass    @staticmethod # known case of __new__    def __new__(S, *more): # real signature unknown; restored from __doc__        """ T.__new__(S, ...) -> a new object with type S, a subtype of T """        pass    def __ne__(self, y): # real signature unknown; restored from __doc__        """ x.__ne__(y) <==> x!=y """        pass    def __repr__(self): # real signature unknown; restored from __doc__        """ x.__repr__() <==> repr(x) """        pass    def __setitem__(self, i, y): # real signature unknown; restored from __doc__        """ x.__setitem__(i, y) <==> x[i]=y """        pass    format = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default    itemsize = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default    ndim = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default    readonly = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default    shape = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default    strides = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default    suboffsets = property(lambda self: object(), lambda self, v: None, lambda self: None)  # defaultclass property(object):    """    property(fget=None, fset=None, fdel=None, doc=None) -> property attribute        fget is a function to be used for getting an attribute value, and likewise    fset is a function for setting, and fdel a function for del‘ing, an    attribute.  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, obj): # real signature unknown; restored from __doc__        """ descr.__delete__(obj) """        pass    def __getattribute__(self, name): # real signature unknown; restored from __doc__        """ x.__getattribute__(‘name‘) <==> x.name """        pass    def __get__(self, obj, type=None): # real signature unknown; restored from __doc__        """ descr.__get__(obj[, type]) -> value """        pass    def __init__(self, fget=None, fset=None, fdel=None, doc=None): # known special case of property.__init__        """        property(fget=None, fset=None, fdel=None, doc=None) -> property attribute                fget is a function to be used for getting an attribute value, and likewise        fset is a function for setting, and fdel a function for del‘ing, an        attribute.  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__(S, *more): # real signature unknown; restored from __doc__        """ T.__new__(S, ...) -> a new object with type S, a subtype of T """        pass    def __set__(self, obj, value): # real signature unknown; restored from __doc__        """ descr.__set__(obj, 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)  # defaultclass reversed(object):    """    reversed(sequence) -> reverse iterator over values of the sequence        Return a reverse iterator    """    def next(self): # real signature unknown; restored from __doc__        """ x.next() -> the next value, or raise StopIteration """        pass    def __getattribute__(self, name): # real signature unknown; restored from __doc__        """ x.__getattribute__(‘name‘) <==> x.name """        pass    def __init__(self, sequence): # real signature unknown; restored from __doc__        pass    def __iter__(self): # real signature unknown; restored from __doc__        """ x.__iter__() <==> iter(x) """        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__(S, *more): # real signature unknown; restored from __doc__        """ T.__new__(S, ...) -> a new object with type S, a subtype of T """        passclass 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 or more sets as a new set.                (i.e. elements that are common to all of the 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, y): # real signature unknown; restored from __doc__        """ x.__and__(y) <==> x&y """        pass    def __cmp__(self, y): # real signature unknown; restored from __doc__        """ x.__cmp__(y) <==> cmp(x,y) """        pass    def __contains__(self, y): # real signature unknown; restored from __doc__        """ x.__contains__(y) <==> y in x. """        pass    def __eq__(self, y): # real signature unknown; restored from __doc__        """ x.__eq__(y) <==> x==y """        pass    def __getattribute__(self, name): # real signature unknown; restored from __doc__        """ x.__getattribute__(‘name‘) <==> x.name """        pass    def __ge__(self, y): # real signature unknown; restored from __doc__        """ x.__ge__(y) <==> x>=y """        pass    def __gt__(self, y): # real signature unknown; restored from __doc__        """ x.__gt__(y) <==> x>y """        pass    def __iand__(self, y): # real signature unknown; restored from __doc__        """ x.__iand__(y) <==> x&=y """        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, y): # real signature unknown; restored from __doc__        """ x.__ior__(y) <==> x|=y """        pass    def __isub__(self, y): # real signature unknown; restored from __doc__        """ x.__isub__(y) <==> x-=y """        pass    def __iter__(self): # real signature unknown; restored from __doc__        """ x.__iter__() <==> iter(x) """        pass    def __ixor__(self, y): # real signature unknown; restored from __doc__        """ x.__ixor__(y) <==> x^=y """        pass    def __len__(self): # real signature unknown; restored from __doc__        """ x.__len__() <==> len(x) """        pass    def __le__(self, y): # real signature unknown; restored from __doc__        """ x.__le__(y) <==> x<=y """        pass    def __lt__(self, y): # real signature unknown; restored from __doc__        """ x.__lt__(y) <==> x<y """        pass    @staticmethod # known case of __new__    def __new__(S, *more): # real signature unknown; restored from __doc__        """ T.__new__(S, ...) -> a new object with type S, a subtype of T """        pass    def __ne__(self, y): # real signature unknown; restored from __doc__        """ x.__ne__(y) <==> x!=y """        pass    def __or__(self, y): # real signature unknown; restored from __doc__        """ x.__or__(y) <==> x|y """        pass    def __rand__(self, y): # real signature unknown; restored from __doc__        """ x.__rand__(y) <==> y&x """        pass    def __reduce__(self, *args, **kwargs): # real signature unknown        """ Return state information for pickling. """        pass    def __repr__(self): # real signature unknown; restored from __doc__        """ x.__repr__() <==> repr(x) """        pass    def __ror__(self, y): # real signature unknown; restored from __doc__        """ x.__ror__(y) <==> y|x """        pass    def __rsub__(self, y): # real signature unknown; restored from __doc__        """ x.__rsub__(y) <==> y-x """        pass    def __rxor__(self, y): # real signature unknown; restored from __doc__        """ x.__rxor__(y) <==> y^x """        pass    def __sizeof__(self): # real signature unknown; restored from __doc__        """ S.__sizeof__() -> size of S in memory, in bytes """        pass    def __sub__(self, y): # real signature unknown; restored from __doc__        """ x.__sub__(y) <==> x-y """        pass    def __xor__(self, y): # real signature unknown; restored from __doc__        """ x.__xor__(y) <==> x^y """        pass    __hash__ = Noneclass 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 __cmp__(self, y): # real signature unknown; restored from __doc__        """ x.__cmp__(y) <==> cmp(x,y) """        pass    def __getattribute__(self, name): # real signature unknown; restored from __doc__        """ x.__getattribute__(‘name‘) <==> x.name """        pass    def __hash__(self): # real signature unknown; restored from __doc__        """ x.__hash__() <==> hash(x) """        pass    def __init__(self, stop): # real signature unknown; restored from __doc__        pass    @staticmethod # known case of __new__    def __new__(S, *more): # real signature unknown; restored from __doc__        """ T.__new__(S, ...) -> a new object with type S, a subtype of T """        pass    def __reduce__(self, *args, **kwargs): # real signature unknown        """ Return state information for pickling. """        pass    def __repr__(self): # real signature unknown; restored from __doc__        """ x.__repr__() <==> repr(x) """        pass    start = property(lambda self: 0)    """:type: int"""    step = property(lambda self: 0)    """:type: int"""    stop = property(lambda self: 0)    """:type: int"""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:         def f(arg1, arg2, ...): ...         f = staticmethod(f)        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 __getattribute__(self, name): # real signature unknown; restored from __doc__        """ x.__getattribute__(‘name‘) <==> x.name """        pass    def __get__(self, obj, type=None): # real signature unknown; restored from __doc__        """ descr.__get__(obj[, type]) -> value """        pass    def __init__(self, function): # real signature unknown; restored from __doc__        pass    @staticmethod # known case of __new__    def __new__(S, *more): # real signature unknown; restored from __doc__        """ T.__new__(S, ...) -> a new object with type S, a subtype of T """        pass    __func__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # defaultclass super(object):    """    super(type, obj) -> bound super object; requires isinstance(obj, type)    super(type) -> unbound super object    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(C, self).meth(arg)    """    def __getattribute__(self, name): # real signature unknown; restored from __doc__        """ x.__getattribute__(‘name‘) <==> x.name """        pass    def __get__(self, obj, type=None): # real signature unknown; restored from __doc__        """ descr.__get__(obj[, type]) -> value """        pass    def __init__(self, type1, type2=None): # known special case of super.__init__        """        super(type, obj) -> bound super object; requires isinstance(obj, type)        super(type) -> unbound super object        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(C, self).meth(arg)        # (copied from class doc)        """        pass    @staticmethod # known case of __new__    def __new__(S, *more): # real signature unknown; restored from __doc__        """ T.__new__(S, ...) -> a new object with type S, a subtype of T """        pass    def __repr__(self): # real signature unknown; restored from __doc__        """ x.__repr__() <==> repr(x) """        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 tuple(object):    """    tuple() -> empty tuple    tuple(iterable) -> tuple initialized from iterable‘s items        If the argument is a tuple, the return value is the same object.    """    def count(self, value): # real signature unknown; restored from __doc__        """ T.count(value) -> integer -- return number of occurrences of value """        return 0    def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__        """        T.index(value, [start, [stop]]) -> integer -- return first index of value.        Raises ValueError if the value is not present.        """        return 0    def __add__(self, y): # real signature unknown; restored from __doc__        """ x.__add__(y) <==> x+y """        pass    def __contains__(self, y): # real signature unknown; restored from __doc__        """ x.__contains__(y) <==> y in x """        pass    def __eq__(self, y): # real signature unknown; restored from __doc__        """ x.__eq__(y) <==> x==y """        pass    def __getattribute__(self, name): # real signature unknown; restored from __doc__        """ x.__getattribute__(‘name‘) <==> x.name """        pass    def __getitem__(self, y): # real signature unknown; restored from __doc__        """ x.__getitem__(y) <==> x[y] """        pass    def __getnewargs__(self, *args, **kwargs): # real signature unknown        pass    def __getslice__(self, i, j): # real signature unknown; restored from __doc__        """        x.__getslice__(i, j) <==> x[i:j]                                      Use of negative indices is not supported.        """        pass    def __ge__(self, y): # real signature unknown; restored from __doc__        """ x.__ge__(y) <==> x>=y """        pass    def __gt__(self, y): # real signature unknown; restored from __doc__        """ x.__gt__(y) <==> x>y """        pass    def __hash__(self): # real signature unknown; restored from __doc__        """ x.__hash__() <==> hash(x) """        pass    def __init__(self, seq=()): # known special case of tuple.__init__        """        tuple() -> empty tuple        tuple(iterable) -> tuple 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): # real signature unknown; restored from __doc__        """ x.__iter__() <==> iter(x) """        pass    def __len__(self): # real signature unknown; restored from __doc__        """ x.__len__() <==> len(x) """        pass    def __le__(self, y): # real signature unknown; restored from __doc__        """ x.__le__(y) <==> x<=y """        pass    def __lt__(self, y): # real signature unknown; restored from __doc__        """ x.__lt__(y) <==> x<y """        pass    def __mul__(self, n): # real signature unknown; restored from __doc__        """ x.__mul__(n) <==> x*n """        pass    @staticmethod # known case of __new__    def __new__(S, *more): # real signature unknown; restored from __doc__        """ T.__new__(S, ...) -> a new object with type S, a subtype of T """        pass    def __ne__(self, y): # real signature unknown; restored from __doc__        """ x.__ne__(y) <==> x!=y """        pass    def __repr__(self): # real signature unknown; restored from __doc__        """ x.__repr__() <==> repr(x) """        pass    def __rmul__(self, n): # real signature unknown; restored from __doc__        """ x.__rmul__(n) <==> n*x """        passclass type(object):    """    type(object) -> the object‘s type    type(name, bases, dict) -> a new type    """    def mro(self): # real signature unknown; restored from __doc__        """        mro() -> list        return a type‘s method resolution order        """        return []    def __call__(self, *more): # real signature unknown; restored from __doc__        """ x.__call__(...) <==> x(...) """        pass    def __delattr__(self, name): # real signature unknown; restored from __doc__        """ x.__delattr__(‘name‘) <==> del x.name """        pass    def __eq__(self, y): # real signature unknown; restored from __doc__        """ x.__eq__(y) <==> x==y """        pass    def __getattribute__(self, name): # real signature unknown; restored from __doc__        """ x.__getattribute__(‘name‘) <==> x.name """        pass    def __ge__(self, y): # real signature unknown; restored from __doc__        """ x.__ge__(y) <==> x>=y """        pass    def __gt__(self, y): # real signature unknown; restored from __doc__        """ x.__gt__(y) <==> x>y """        pass    def __hash__(self): # real signature unknown; restored from __doc__        """ x.__hash__() <==> hash(x) """        pass    def __init__(cls, what, bases=None, dict=None): # known special case of type.__init__        """        type(object) -> the object‘s type        type(name, bases, dict) -> a new type        # (copied from class doc)        """        pass    def __instancecheck__(self): # real signature unknown; restored from __doc__        """        __instancecheck__() -> bool        check if an object is an instance        """        return False    def __le__(self, y): # real signature unknown; restored from __doc__        """ x.__le__(y) <==> x<=y """        pass    def __lt__(self, y): # real signature unknown; restored from __doc__        """ x.__lt__(y) <==> x<y """        pass    @staticmethod # known case of __new__    def __new__(S, *more): # real signature unknown; restored from __doc__        """ T.__new__(S, ...) -> a new object with type S, a subtype of T """        pass    def __ne__(self, y): # real signature unknown; restored from __doc__        """ x.__ne__(y) <==> x!=y """        pass    def __repr__(self): # real signature unknown; restored from __doc__        """ x.__repr__() <==> repr(x) """        pass    def __setattr__(self, name, value): # real signature unknown; restored from __doc__        """ x.__setattr__(‘name‘, value) <==> x.name = value """        pass    def __subclasscheck__(self): # real signature unknown; restored from __doc__        """        __subclasscheck__() -> bool        check if a class is a subclass        """        return False    def __subclasses__(self): # real signature unknown; restored from __doc__        """ __subclasses__() -> list of immediate subclasses """        return []    __abstractmethods__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default    __bases__ = (        object,    )    __base__ = object    __basicsize__ = 436    __dictoffset__ = 132    __dict__ = None # (!) real value is ‘‘    __flags__ = -2146544149    __itemsize__ = 20    __mro__ = (        None, # (!) forward: type, real value is ‘‘        object,    )    __name__ = ‘type‘    __weakrefoffset__ = 184class unicode(basestring):    """    unicode(object=‘‘) -> unicode object    unicode(string[, encoding[, errors]]) -> unicode object        Create a new Unicode object from the given encoded string.    encoding defaults to the current default string encoding.    errors can be ‘strict‘, ‘replace‘ or ‘ignore‘ and defaults to ‘strict‘.    """    def capitalize(self): # real signature unknown; restored from __doc__        """        S.capitalize() -> unicode                Return a capitalized version of S, i.e. make the first character        have upper case and the rest lower case.        """        return u""    def center(self, width, fillchar=None): # real signature unknown; restored from __doc__        """        S.center(width[, fillchar]) -> unicode                Return S centered in a Unicode string of length width. Padding is        done using the specified fill character (default is a space)        """        return u""    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        Unicode string S[start:end].  Optional arguments start and end are        interpreted as in slice notation.        """        return 0    def decode(self, encoding=None, errors=None): # real signature unknown; restored from __doc__        """        S.decode([encoding[,errors]]) -> string or unicode                Decodes S using the codec registered for encoding. encoding defaults        to the default encoding. errors may be given to set a different error        handling scheme. Default is ‘strict‘ meaning that encoding errors raise        a UnicodeDecodeError. Other possible values are ‘ignore‘ and ‘replace‘        as well as any other name registered with codecs.register_error that is        able to handle UnicodeDecodeErrors.        """        return ""    def encode(self, encoding=None, errors=None): # real signature unknown; restored from __doc__        """        S.encode([encoding[,errors]]) -> string or unicode                Encodes S using the codec registered for encoding. encoding defaults        to the default encoding. errors may be given to set a different error        handling scheme. 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.        """        return ""    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, tabsize=None): # real signature unknown; restored from __doc__        """        S.expandtabs([tabsize]) -> unicode                Return a copy of S where all tab characters are expanded using spaces.        If tabsize is not given, a tab size of 8 characters is assumed.        """        return u""    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(*args, **kwargs): # known special case of unicode.format        """        S.format(*args, **kwargs) -> unicode                Return a formatted version of S, using substitutions from args and kwargs.        The substitutions are identified by braces (‘{‘ and ‘}‘).        """        pass    def index(self, sub, start=None, end=None): # real signature unknown; restored from __doc__        """        S.index(sub [,start [,end]]) -> int                Like S.find() but raise ValueError when the substring is not found.        """        return 0    def isalnum(self): # real signature unknown; restored from __doc__        """        S.isalnum() -> bool                Return True if all characters in S are alphanumeric        and there is at least one character in S, False otherwise.        """        return False    def isalpha(self): # real signature unknown; restored from __doc__        """        S.isalpha() -> bool                Return True if all characters in S are alphabetic        and there is at least one character in S, False otherwise.        """        return False    def isdecimal(self): # real signature unknown; restored from __doc__        """        S.isdecimal() -> bool                Return True if there are only decimal characters in S,        False otherwise.        """        return False    def isdigit(self): # real signature unknown; restored from __doc__        """        S.isdigit() -> bool                Return True if all characters in S are digits        and there is at least one character in S, False otherwise.        """        return False    def islower(self): # real signature unknown; restored from __doc__        """        S.islower() -> bool                Return True if all cased characters in S are lowercase and there is        at least one cased character in S, False otherwise.        """        return False    def isnumeric(self): # real signature unknown; restored from __doc__        """        S.isnumeric() -> bool                Return True if there are only numeric characters in S,        False otherwise.        """        return False    def isspace(self): # real signature unknown; restored from __doc__        """        S.isspace() -> bool                Return True if all characters in S are whitespace        and there is at least one character in S, False otherwise.        """        return False    def istitle(self): # real signature unknown; restored from __doc__        """        S.istitle() -> bool                Return True if S is a titlecased string and there is at least one        character in S, i.e. upper- and titlecase 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__        """        S.isupper() -> bool                Return True if all cased characters in S are uppercase and there is        at least one cased character in S, False otherwise.        """        return False    def join(self, iterable): # real signature unknown; restored from __doc__        """        S.join(iterable) -> unicode                Return a string which is the concatenation of the strings in the        iterable.  The separator between elements is S.        """        return u""    def ljust(self, width, fillchar=None): # real signature unknown; restored from __doc__        """        S.ljust(width[, fillchar]) -> int                Return S left-justified in a Unicode string of length width. Padding is        done using the specified fill character (default is a space).        """        return 0    def lower(self): # real signature unknown; restored from __doc__        """        S.lower() -> unicode                Return a copy of the string S converted to lowercase.        """        return u""    def lstrip(self, chars=None): # real signature unknown; restored from __doc__        """        S.lstrip([chars]) -> unicode                Return a copy of the string S with leading whitespace removed.        If chars is given and not None, remove characters in chars instead.        If chars is a str, it will be converted to unicode before stripping        """        return u""    def partition(self, sep): # real signature unknown; restored from __doc__        """        S.partition(sep) -> (head, sep, tail)                Search for the separator sep in S, and return the part before it,        the separator itself, and the part after it.  If the separator is not        found, return S and two empty strings.        """        pass    def replace(self, old, new, count=None): # real signature unknown; restored from __doc__        """        S.replace(old, new[, count]) -> unicode                Return a copy of S with all occurrences of substring        old replaced by new.  If the optional argument count is        given, only the first count occurrences are replaced.        """        return u""    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                Like S.rfind() but raise ValueError when the substring is not found.        """        return 0    def rjust(self, width, fillchar=None): # real signature unknown; restored from __doc__        """        S.rjust(width[, fillchar]) -> unicode                Return S right-justified in a Unicode string of length width. Padding is        done using the specified fill character (default is a space).        """        return u""    def rpartition(self, sep): # real signature unknown; restored from __doc__        """        S.rpartition(sep) -> (head, sep, tail)                Search for the separator sep in S, starting at the end of S, and return        the part before it, the separator itself, and the part after it.  If the        separator is not found, return two empty strings and S.        """        pass    def rsplit(self, sep=None, maxsplit=None): # real signature unknown; restored from __doc__        """        S.rsplit([sep [,maxsplit]]) -> list of strings                Return a list of the words in S, using sep as the        delimiter string, starting at the end of the string and        working to the front.  If maxsplit is given, at most maxsplit        splits are done. If sep is not specified, any whitespace string        is a separator.        """        return []    def rstrip(self, chars=None): # real signature unknown; restored from __doc__        """        S.rstrip([chars]) -> unicode                Return a copy of the string S with trailing whitespace removed.        If chars is given and not None, remove characters in chars instead.        If chars is a str, it will be converted to unicode before stripping        """        return u""    def split(self, sep=None, maxsplit=None): # real signature unknown; restored from __doc__        """        S.split([sep [,maxsplit]]) -> list of strings                Return a list of the words in S, using sep as the        delimiter string.  If maxsplit is given, at most maxsplit        splits are done. If sep is not specified or is None, any        whitespace string is a separator and empty strings are        removed from the result.        """        return []    def splitlines(self, keepends=False): # real signature unknown; restored from __doc__        """        S.splitlines(keepends=False) -> list of strings                Return a list of the lines in S, breaking at line boundaries.        Line breaks are not included in the resulting list unless keepends        is given and true.        """        return []    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, chars=None): # real signature unknown; restored from __doc__        """        S.strip([chars]) -> unicode                Return a copy of the string S with leading and trailing        whitespace removed.        If chars is given and not None, remove characters in chars instead.        If chars is a str, it will be converted to unicode before stripping        """        return u""    def swapcase(self): # real signature unknown; restored from __doc__        """        S.swapcase() -> unicode                Return a copy of S with uppercase characters converted to lowercase        and vice versa.        """        return u""    def title(self): # real signature unknown; restored from __doc__        """        S.title() -> unicode                Return a titlecased version of S, i.e. words start with title case        characters, all remaining cased characters have lower case.        """        return u""    def translate(self, table): # real signature unknown; restored from __doc__        """        S.translate(table) -> unicode                Return a copy of the string S, where all characters have been mapped        through the given translation table, which must be a mapping of        Unicode ordinals to Unicode ordinals, Unicode strings or None.        Unmapped characters are left untouched. Characters mapped to None        are deleted.        """        return u""    def upper(self): # real signature unknown; restored from __doc__        """        S.upper() -> unicode                Return a copy of S converted to uppercase.        """        return u""    def zfill(self, width): # real signature unknown; restored from __doc__        """        S.zfill(width) -> unicode                Pad a numeric string S with zeros on the left, to fill a field        of the specified width. The string S is never truncated.        """        return u""    def _formatter_field_name_split(self, *args, **kwargs): # real signature unknown        pass    def _formatter_parser(self, *args, **kwargs): # real signature unknown        pass    def __add__(self, y): # real signature unknown; restored from __doc__        """ x.__add__(y) <==> x+y """        pass    def __contains__(self, y): # real signature unknown; restored from __doc__        """ x.__contains__(y) <==> y in x """        pass    def __eq__(self, y): # real signature unknown; restored from __doc__        """ x.__eq__(y) <==> x==y """        pass    def __format__(self, format_spec): # real signature unknown; restored from __doc__        """        S.__format__(format_spec) -> unicode                Return a formatted version of S as described by format_spec.        """        return u""    def __getattribute__(self, name): # real signature unknown; restored from __doc__        """ x.__getattribute__(‘name‘) <==> x.name """        pass    def __getitem__(self, y): # real signature unknown; restored from __doc__        """ x.__getitem__(y) <==> x[y] """        pass    def __getnewargs__(self, *args, **kwargs): # real signature unknown        pass    def __getslice__(self, i, j): # real signature unknown; restored from __doc__        """        x.__getslice__(i, j) <==> x[i:j]                                      Use of negative indices is not supported.        """        pass    def __ge__(self, y): # real signature unknown; restored from __doc__        """ x.__ge__(y) <==> x>=y """        pass    def __gt__(self, y): # real signature unknown; restored from __doc__        """ x.__gt__(y) <==> x>y """        pass    def __hash__(self): # real signature unknown; restored from __doc__        """ x.__hash__() <==> hash(x) """        pass    def __init__(self, string=u‘‘, encoding=None, errors=‘strict‘): # known special case of unicode.__init__        """        unicode(object=‘‘) -> unicode object        unicode(string[, encoding[, errors]]) -> unicode object                Create a new Unicode object from the given encoded string.        encoding defaults to the current default string encoding.        errors can be ‘strict‘, ‘replace‘ or ‘ignore‘ and defaults to ‘strict‘.        # (copied from class doc)        """        pass    def __len__(self): # real signature unknown; restored from __doc__        """ x.__len__() <==> len(x) """        pass    def __le__(self, y): # real signature unknown; restored from __doc__        """ x.__le__(y) <==> x<=y """        pass    def __lt__(self, y): # real signature unknown; restored from __doc__        """ x.__lt__(y) <==> x<y """        pass    def __mod__(self, y): # real signature unknown; restored from __doc__        """ x.__mod__(y) <==> x%y """        pass    def __mul__(self, n): # real signature unknown; restored from __doc__        """ x.__mul__(n) <==> x*n """        pass    @staticmethod # known case of __new__    def __new__(S, *more): # real signature unknown; restored from __doc__        """ T.__new__(S, ...) -> a new object with type S, a subtype of T """        pass    def __ne__(self, y): # real signature unknown; restored from __doc__        """ x.__ne__(y) <==> x!=y """        pass    def __repr__(self): # real signature unknown; restored from __doc__        """ x.__repr__() <==> repr(x) """        pass    def __rmod__(self, y): # real signature unknown; restored from __doc__        """ x.__rmod__(y) <==> y%x """        pass    def __rmul__(self, n): # real signature unknown; restored from __doc__        """ x.__rmul__(n) <==> n*x """        pass    def __sizeof__(self): # real signature unknown; restored from __doc__        """ S.__sizeof__() -> size of S in memory, in bytes """        pass    def __str__(self): # real signature unknown; restored from __doc__        """ x.__str__() <==> str(x) """        passclass xrange(object):    """    xrange(stop) -> xrange object    xrange(start, stop[, step]) -> xrange object        Like range(), but instead of returning a list, returns an object that    generates the numbers in the range on demand.  For looping, this is     slightly faster than range() and more memory efficient.    """    def __getattribute__(self, name): # real signature unknown; restored from __doc__        """ x.__getattribute__(‘name‘) <==> x.name """        pass    def __getitem__(self, y): # real signature unknown; restored from __doc__        """ x.__getitem__(y) <==> x[y] """        pass    def __init__(self, stop): # real signature unknown; restored from __doc__        pass    def __iter__(self): # real signature unknown; restored from __doc__        """ x.__iter__() <==> iter(x) """        pass    def __len__(self): # real signature unknown; restored from __doc__        """ x.__len__() <==> len(x) """        pass    @staticmethod # known case of __new__    def __new__(S, *more): # real signature unknown; restored from __doc__        """ T.__new__(S, ...) -> a new object with type S, a subtype of T """        pass    def __reduce__(self, *args, **kwargs): # real signature unknown        pass    def __repr__(self): # real signature unknown; restored from __doc__        """ x.__repr__() <==> repr(x) """        pass    def __reversed__(self, *args, **kwargs): # real signature unknown        """ Returns a reverse iterator. """        pass# variables with complex valuesEllipsis = None # (!) real value is ‘‘NotImplemented = None # (!) real value is ‘‘