save project

diy2.py

@@ -9,9 +9,9 @@ while True:
         if name == username and password == userpassword:
             print("登录成功!")
             break
+        if name != userpassword:
+            print("用户错误")
             exit()
-        elif name != userpassword:
-            print("用户")
         else :
             print("密码错误")                                      
 print("欢迎来到贝尔编程!")

fsdf.py

+from typing import (
+    TypeVar, Iterator, Iterable, NoReturn, overload, Container,
+    Sequence, MutableSequence, Mapping, MutableMapping, Tuple, List, Any, Dict, Callable, Generic,
+    Set, AbstractSet, FrozenSet, MutableSet, Sized, Reversible, SupportsInt, SupportsFloat, SupportsAbs,
+    SupportsComplex, IO, BinaryIO, Union,
+    ItemsView, KeysView, ValuesView, ByteString, Optional, AnyStr, Type, Text,
+    Protocol,
+)
+from abc import abstractmethod, ABCMeta
+from ast import mod, AST
+from types import TracebackType, CodeType
+import sys
+
+if sys.version_info >= (3,):
+    from typing import SupportsBytes, SupportsRound
+
+_T = TypeVar('_T')
+_T_co = TypeVar('_T_co', covariant=True)
+_KT = TypeVar('_KT')
+_VT = TypeVar('_VT')
+_S = TypeVar('_S')
+_T1 = TypeVar('_T1')
+_T2 = TypeVar('_T2')
+_T3 = TypeVar('_T3')
+_T4 = TypeVar('_T4')
+_T5 = TypeVar('_T5')
+_TT = TypeVar('_TT', bound='type')
+
+class object:
+    __doc__: Optional[str]
+    __dict__: Dict[str, Any]
+    __slots__: Union[Text, Iterable[Text]]
+    __module__: str
+    if sys.version_info >= (3, 6):
+        __annotations__: Dict[str, Any]
+
+    @property
+    def __class__(self: _T) -> Type[_T]: ...
+    @__class__.setter
+    def __class__(self, __type: Type[object]) -> None: ...
+    def __init__(self) -> None: ...
+    def __new__(cls) -> Any: ...
+    def __setattr__(self, name: str, value: Any) -> None: ...
+    def __eq__(self, o: object) -> bool: ...
+    def __ne__(self, o: object) -> bool: ...
+    def __str__(self) -> str: ...
+    def __repr__(self) -> str: ...
+    def __hash__(self) -> int: ...
+    def __format__(self, format_spec: str) -> str: ...
+    def __getattribute__(self, name: str) -> Any: ...
+    def __delattr__(self, name: str) -> None: ...
+    def __sizeof__(self) -> int: ...
+    def __reduce__(self) -> tuple: ...
+    def __reduce_ex__(self, protocol: int) -> tuple: ...
+    if sys.version_info >= (3,):
+        def __dir__(self) -> Iterable[str]: ...
+    if sys.version_info >= (3, 6):
+        def __init_subclass__(cls) -> None: ...
+
+class staticmethod(object):  # Special, only valid as a decorator.
+    __func__: Callable
+    if sys.version_info >= (3,):
+        __isabstractmethod__: bool
+
+    def __init__(self, f: Callable) -> None: ...
+    def __new__(cls: Type[_T], *args: Any, **kwargs: Any) -> _T: ...
+    def __get__(self, obj: _T, type: Optional[Type[_T]] = ...) -> Callable: ...
+
+class classmethod(object):  # Special, only valid as a decorator.
+    __func__: Callable
+    if sys.version_info >= (3,):
+        __isabstractmethod__: bool
+
+    def __init__(self, f: Callable) -> None: ...
+    def __new__(cls: Type[_T], *args: Any, **kwargs: Any) -> _T: ...
+    def __get__(self, obj: _T, type: Optional[Type[_T]] = ...) -> Callable: ...
+
+class type(object):
+    __base__: type
+    __bases__: Tuple[type, ...]
+    __basicsize__: int
+    __dict__: Dict[str, Any]
+    __dictoffset__: int
+    __flags__: int
+    __itemsize__: int
+    __module__: str
+    __mro__: Tuple[type, ...]
+    __name__: str
+    if sys.version_info >= (3,):
+        __qualname__: str
+        __text_signature__: Optional[str]
+    __weakrefoffset__: int
+
+    @overload
+    def __init__(self, o: object) -> None: ...
+    @overload
+    def __init__(self, name: str, bases: Tuple[type, ...], dict: Dict[str, Any]) -> None: ...
+    @overload
+    def __new__(cls, o: object) -> type: ...
+    @overload
+    def __new__(cls, name: str, bases: Tuple[type, ...], namespace: Dict[str, Any]) -> type: ...
+    def __call__(self, *args: Any, **kwds: Any) -> Any: ...
+    def __subclasses__(self: _TT) -> List[_TT]: ...
+    # Note: the documentation doesnt specify what the return type is, the standard
+    # implementation seems to be returning a list.
+    def mro(self) -> List[type]: ...
+    def __instancecheck__(self, instance: Any) -> bool: ...
+    def __subclasscheck__(self, subclass: type) -> bool: ...
+    if sys.version_info >= (3,):
+        @classmethod
+        def __prepare__(metacls, __name: str, __bases: Tuple[type, ...], **kwds: Any) -> Mapping[str, Any]: ...
+
+class super(object):
+    if sys.version_info >= (3,):
+        @overload
+        def __init__(self, t: Any, obj: Any) -> None: ...
+        @overload
+        def __init__(self, t: Any) -> None: ...
+        @overload
+        def __init__(self) -> None: ...
+    else:
+        @overload
+        def __init__(self, t: Any, obj: Any) -> None: ...
+        @overload
+        def __init__(self, t: Any) -> None: ...
+
+class int:
+    @overload
+    def __init__(self, x: Union[Text, bytes, SupportsInt] = ...) -> None: ...
+    @overload
+    def __init__(self, x: Union[Text, bytes, bytearray], base: int) -> None: ...
+
+    @property
+    def real(self) -> int: ...
+    @property
+    def imag(self) -> int: ...
+    @property
+    def numerator(self) -> int: ...
+    @property
+    def denominator(self) -> int: ...
+    def conjugate(self) -> int: ...
+
+    def bit_length(self) -> int: ...
+    if sys.version_info >= (3,):
+        def to_bytes(self, length: int, byteorder: str, *, signed: bool = ...) -> bytes: ...
+        @classmethod
+        def from_bytes(cls, bytes: Sequence[int], byteorder: str, *,
+                       signed: bool = ...) -> int: ...  # TODO buffer object argument
+
+    def __add__(self, x: int) -> int: ...
+    def __sub__(self, x: int) -> int: ...
+    def __mul__(self, x: int) -> int: ...
+    def __floordiv__(self, x: int) -> int: ...
+    if sys.version_info < (3,):
+        def __div__(self, x: int) -> int: ...
+    def __truediv__(self, x: int) -> float: ...
+    def __mod__(self, x: int) -> int: ...
+    def __divmod__(self, x: int) -> Tuple[int, int]: ...
+    def __radd__(self, x: int) -> int: ...
+    def __rsub__(self, x: int) -> int: ...
+    def __rmul__(self, x: int) -> int: ...
+    def __rfloordiv__(self, x: int) -> int: ...
+    if sys.version_info < (3,):
+        def __rdiv__(self, x: int) -> int: ...
+    def __rtruediv__(self, x: int) -> float: ...
+    def __rmod__(self, x: int) -> int: ...
+    def __rdivmod__(self, x: int) -> Tuple[int, int]: ...
+    def __pow__(self, x: int) -> Any: ...  # Return type can be int or float, depending on x.
+    def __rpow__(self, x: int) -> Any: ...
+    def __and__(self, n: int) -> int: ...
+    def __or__(self, n: int) -> int: ...
+    def __xor__(self, n: int) -> int: ...
+    def __lshift__(self, n: int) -> int: ...
+    def __rshift__(self, n: int) -> int: ...
+    def __rand__(self, n: int) -> int: ...
+    def __ror__(self, n: int) -> int: ...
+    def __rxor__(self, n: int) -> int: ...
+    def __rlshift__(self, n: int) -> int: ...
+    def __rrshift__(self, n: int) -> int: ...
+    def __neg__(self) -> int: ...
+    def __pos__(self) -> int: ...
+    def __invert__(self) -> int: ...
+    if sys.version_info >= (3,):
+        def __round__(self, ndigits: Optional[int] = ...) -> int: ...
+    def __getnewargs__(self) -> Tuple[int]: ...
+
+    def __eq__(self, x: object) -> bool: ...
+    def __ne__(self, x: object) -> bool: ...
+    def __lt__(self, x: int) -> bool: ...
+    def __le__(self, x: int) -> bool: ...
+    def __gt__(self, x: int) -> bool: ...
+    def __ge__(self, x: int) -> bool: ...
+
+    def __str__(self) -> str: ...
+    def __float__(self) -> float: ...
+    def __int__(self) -> int: ...
+    def __abs__(self) -> int: ...
+    def __hash__(self) -> int: ...
+    if sys.version_info >= (3,):
+        def __bool__(self) -> bool: ...
+    else:
+        def __nonzero__(self) -> bool: ...
+    def __index__(self) -> int: ...
+
+class float:
+    def __init__(self, x: Union[SupportsFloat, Text, bytes, bytearray] = ...) -> None: ...
+    def as_integer_ratio(self) -> Tuple[int, int]: ...
+    def hex(self) -> str: ...
+    def is_integer(self) -> bool: ...
+    @classmethod
+    def fromhex(cls, s: str) -> float: ...
+
+    @property
+    def real(self) -> float: ...
+    @property
+    def imag(self) -> float: ...
+    def conjugate(self) -> float: ...
+
+    def __add__(self, x: float) -> float: ...
+    def __sub__(self, x: float) -> float: ...
+    def __mul__(self, x: float) -> float: ...
+    def __floordiv__(self, x: float) -> float: ...
+    if sys.version_info < (3,):
+        def __div__(self, x: float) -> float: ...
+    def __truediv__(self, x: float) -> float: ...
+    def __mod__(self, x: float) -> float: ...
+    def __divmod__(self, x: float) -> Tuple[float, float]: ...
+    def __pow__(self, x: float) -> float: ...  # In Python 3, returns complex if self is negative and x is not whole
+    def __radd__(self, x: float) -> float: ...
+    def __rsub__(self, x: float) -> float: ...
+    def __rmul__(self, x: float) -> float: ...
+    def __rfloordiv__(self, x: float) -> float: ...
+    if sys.version_info < (3,):
+        def __rdiv__(self, x: float) -> float: ...
+    def __rtruediv__(self, x: float) -> float: ...
+    def __rmod__(self, x: float) -> float: ...
+    def __rdivmod__(self, x: float) -> Tuple[float, float]: ...
+    def __rpow__(self, x: float) -> float: ...
+    def __getnewargs__(self) -> Tuple[float]: ...
+    if sys.version_info >= (3,):
+        @overload
+        def __round__(self) -> int: ...
+        @overload
+        def __round__(self, ndigits: None) -> int: ...
+        @overload
+        def __round__(self, ndigits: int) -> float: ...
+
+    def __eq__(self, x: object) -> bool: ...
+    def __ne__(self, x: object) -> bool: ...
+    def __lt__(self, x: float) -> bool: ...
+    def __le__(self, x: float) -> bool: ...
+    def __gt__(self, x: float) -> bool: ...
+    def __ge__(self, x: float) -> bool: ...
+    def __neg__(self) -> float: ...
+    def __pos__(self) -> float: ...
+
+    def __str__(self) -> str: ...
+    def __int__(self) -> int: ...
+    def __float__(self) -> float: ...
+    def __abs__(self) -> float: ...
+    def __hash__(self) -> int: ...
+    if sys.version_info >= (3,):
+        def __bool__(self) -> bool: ...
+    else:
+        def __nonzero__(self) -> bool: ...
+
+class complex:
+    @overload
+    def __init__(self, re: float = ..., im: float = ...) -> None: ...
+    @overload
+    def __init__(self, s: str) -> None: ...
+    @overload
+    def __init__(self, s: SupportsComplex) -> None: ...
+
+    @property
+    def real(self) -> float: ...
+    @property
+    def imag(self) -> float: ...
+
+    def conjugate(self) -> complex: ...
+
+    def __add__(self, x: complex) -> complex: ...
+    def __sub__(self, x: complex) -> complex: ...
+    def __mul__(self, x: complex) -> complex: ...
+    def __pow__(self, x: complex) -> complex: ...
+    if sys.version_info < (3,):
+        def __div__(self, x: complex) -> complex: ...
+    def __truediv__(self, x: complex) -> complex: ...
+    def __radd__(self, x: complex) -> complex: ...
+    def __rsub__(self, x: complex) -> complex: ...
+    def __rmul__(self, x: complex) -> complex: ...
+    def __rpow__(self, x: complex) -> complex: ...
+    if sys.version_info < (3,):
+        def __rdiv__(self, x: complex) -> complex: ...
+    def __rtruediv__(self, x: complex) -> complex: ...
+
+    def __eq__(self, x: object) -> bool: ...
+    def __ne__(self, x: object) -> bool: ...
+    def __neg__(self) -> complex: ...
+    def __pos__(self) -> complex: ...
+
+    def __str__(self) -> str: ...
+    def __complex__(self) -> complex: ...
+    def __abs__(self) -> float: ...
+    def __hash__(self) -> int: ...
+    if sys.version_info >= (3,):
+        def __bool__(self) -> bool: ...
+    else:
+        def __nonzero__(self) -> bool: ...
+
+if sys.version_info >= (3,):
+    _str_base = object
+else:
+    class basestring(metaclass=ABCMeta): ...
+
+    class unicode(basestring, Sequence[unicode]):
+        @overload
+        def __init__(self) -> None: ...
+        @overload
+        def __init__(self, o: object) -> None: ...
+        @overload
+        def __init__(self, o: str, encoding: unicode = ..., errors: unicode = ...) -> None: ...
+        def capitalize(self) -> unicode: ...
+        def center(self, width: int, fillchar: unicode = ...) -> unicode: ...
+        def count(self, x: unicode) -> int: ...
+        def decode(self, encoding: unicode = ..., errors: unicode = ...) -> unicode: ...
+        def encode(self, encoding: unicode = ..., errors: unicode = ...) -> str: ...
+        def endswith(self, suffix: Union[unicode, Tuple[unicode, ...]], start: int = ...,
+                     end: int = ...) -> bool: ...
+        def expandtabs(self, tabsize: int = ...) -> unicode: ...
+        def find(self, sub: unicode, start: int = ..., end: int = ...) -> int: ...
+        def format(self, *args: Any, **kwargs: Any) -> unicode: ...
+        def index(self, sub: unicode, start: int = ..., end: int = ...) -> int: ...
+        def isalnum(self) -> bool: ...
+        def isalpha(self) -> bool: ...
+        def isdecimal(self) -> bool: ...
+        def isdigit(self) -> bool: ...
+        def isidentifier(self) -> bool: ...
+        def islower(self) -> bool: ...
+        def isnumeric(self) -> bool: ...
+        def isprintable(self) -> bool: ...
+        def isspace(self) -> bool: ...
+        def istitle(self) -> bool: ...
+        def isupper(self) -> bool: ...
+        def join(self, iterable: Iterable[unicode]) -> unicode: ...
+        def ljust(self, width: int, fillchar: unicode = ...) -> unicode: ...
+        def lower(self) -> unicode: ...
+        def lstrip(self, chars: unicode = ...) -> unicode: ...
+        def partition(self, sep: unicode) -> Tuple[unicode, unicode, unicode]: ...
+        def replace(self, old: unicode, new: unicode, count: int = ...) -> unicode: ...
+        def rfind(self, sub: unicode, start: int = ..., end: int = ...) -> int: ...
+        def rindex(self, sub: unicode, start: int = ..., end: int = ...) -> int: ...
+        def rjust(self, width: int, fillchar: unicode = ...) -> unicode: ...
+        def rpartition(self, sep: unicode) -> Tuple[unicode, unicode, unicode]: ...
+        def rsplit(self, sep: Optional[unicode] = ..., maxsplit: int = ...) -> List[unicode]: ...
+        def rstrip(self, chars: unicode = ...) -> unicode: ...
+        def split(self, sep: Optional[unicode] = ..., maxsplit: int = ...) -> List[unicode]: ...
+        def splitlines(self, keepends: bool = ...) -> List[unicode]: ...
+        def startswith(self, prefix: Union[unicode, Tuple[unicode, ...]], start: int = ...,
+                       end: int = ...) -> bool: ...
+        def strip(self, chars: unicode = ...) -> unicode: ...
+        def swapcase(self) -> unicode: ...
+        def title(self) -> unicode: ...
+        def translate(self, table: Union[Dict[int, Any], unicode]) -> unicode: ...
+        def upper(self) -> unicode: ...
+        def zfill(self, width: int) -> unicode: ...
+
+        @overload
+        def __getitem__(self, i: int) -> unicode: ...
+        @overload
+        def __getitem__(self, s: slice) -> unicode: ...
+        def __getslice__(self, start: int, stop: int) -> unicode: ...
+        def __add__(self, s: unicode) -> unicode: ...
+        def __mul__(self, n: int) -> unicode: ...
+        def __rmul__(self, n: int) -> unicode: ...
+        def __mod__(self, x: Any) -> unicode: ...
+        def __eq__(self, x: object) -> bool: ...
+        def __ne__(self, x: object) -> bool: ...
+        def __lt__(self, x: unicode) -> bool: ...
+        def __le__(self, x: unicode) -> bool: ...
+        def __gt__(self, x: unicode) -> bool: ...
+        def __ge__(self, x: unicode) -> bool: ...
+
+        def __len__(self) -> int: ...
+        # The argument type is incompatible with Sequence
+        def __contains__(self, s: Union[unicode, bytes]) -> bool: ...  # type: ignore
+        def __iter__(self) -> Iterator[unicode]: ...
+        def __str__(self) -> str: ...
+        def __repr__(self) -> str: ...
+        def __int__(self) -> int: ...
+        def __float__(self) -> float: ...
+        def __hash__(self) -> int: ...
+        def __getnewargs__(self) -> Tuple[unicode]: ...
+
+    _str_base = basestring
+
+class str(Sequence[str], _str_base):
+    if sys.version_info >= (3,):
+        @overload
+        def __init__(self, o: object = ...) -> None: ...
+        @overload
+        def __init__(self, o: bytes, encoding: str = ..., errors: str = ...) -> None: ...
+    else:
+        def __init__(self, o: object = ...) -> None: ...
+
+    def capitalize(self) -> str: ...
+    if sys.version_info >= (3, 3):
+        def casefold(self) -> str: ...
+    def center(self, width: int, fillchar: str = ...) -> str: ...
+    def count(self, x: Text, __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ...
+    if sys.version_info < (3,):
+        def decode(self, encoding: Text = ..., errors: Text = ...) -> unicode: ...
+    def encode(self, encoding: Text = ..., errors: Text = ...) -> bytes: ...
+    if sys.version_info >= (3,):
+        def endswith(self, suffix: Union[Text, Tuple[Text, ...]], start: Optional[int] = ...,
+                     end: Optional[int] = ...) -> bool: ...
+    else:
+        def endswith(self, suffix: Union[Text, Tuple[Text, ...]]) -> bool: ...
+    def expandtabs(self, tabsize: int = ...) -> str: ...
+    def find(self, sub: Text, __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ...
+    def format(self, *args: Any, **kwargs: Any) -> str: ...
+    if sys.version_info >= (3,):
+        def format_map(self, map: Mapping[str, Any]) -> str: ...
+    def index(self, sub: Text, __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ...
+    def isalnum(self) -> bool: ...
+    def isalpha(self) -> bool: ...
+    if sys.version_info >= (3, 7):
+        def isascii(self) -> bool: ...
+    if sys.version_info >= (3,):
+        def isdecimal(self) -> bool: ...
+    def isdigit(self) -> bool: ...
+    if sys.version_info >= (3,):
+        def isidentifier(self) -> bool: ...
+    def islower(self) -> bool: ...
+    if sys.version_info >= (3,):
+        def isnumeric(self) -> bool: ...
+        def isprintable(self) -> bool: ...
+    def isspace(self) -> bool: ...
+    def istitle(self) -> bool: ...
+    def isupper(self) -> bool: ...
+    if sys.version_info >= (3,):
+        def join(self, iterable: Iterable[str]) -> str: ...
+    else:
+        def join(self, iterable: Iterable[AnyStr]) -> AnyStr: ...
+    def ljust(self, width: int, fillchar: str = ...) -> str: ...
+    def lower(self) -> str: ...
+    if sys.version_info >= (3,):
+        def lstrip(self, chars: Optional[str] = ...) -> str: ...
+        def partition(self, sep: str) -> Tuple[str, str, str]: ...
+        def replace(self, old: str, new: str, count: int = ...) -> str: ...
+    else:
+        @overload
+        def lstrip(self, chars: str = ...) -> str: ...
+        @overload
+        def lstrip(self, chars: unicode) -> unicode: ...
+        @overload
+        def partition(self, sep: bytearray) -> Tuple[str, bytearray, str]: ...
+        @overload
+        def partition(self, sep: str) -> Tuple[str, str, str]: ...
+        @overload
+        def partition(self, sep: unicode) -> Tuple[unicode, unicode, unicode]: ...
+        def replace(self, old: AnyStr, new: AnyStr, count: int = ...) -> AnyStr: ...
+    def rfind(self, sub: Text, __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ...
+    def rindex(self, sub: Text, __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ...
+    def rjust(self, width: int, fillchar: str = ...) -> str: ...
+    if sys.version_info >= (3,):
+        def rpartition(self, sep: str) -> Tuple[str, str, str]: ...
+        def rsplit(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[str]: ...
+        def rstrip(self, chars: Optional[str] = ...) -> str: ...
+        def split(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[str]: ...
+    else:
+        @overload
+        def rpartition(self, sep: bytearray) -> Tuple[str, bytearray, str]: ...
+        @overload
+        def rpartition(self, sep: str) -> Tuple[str, str, str]: ...
+        @overload
+        def rpartition(self, sep: unicode) -> Tuple[unicode, unicode, unicode]: ...
+        @overload
+        def rsplit(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[str]: ...
+        @overload
+        def rsplit(self, sep: unicode, maxsplit: int = ...) -> List[unicode]: ...
+        @overload
+        def rstrip(self, chars: str = ...) -> str: ...
+        @overload
+        def rstrip(self, chars: unicode) -> unicode: ...
+        @overload
+        def split(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[str]: ...
+        @overload
+        def split(self, sep: unicode, maxsplit: int = ...) -> List[unicode]: ...
+    def splitlines(self, keepends: bool = ...) -> List[str]: ...
+    if sys.version_info >= (3,):
+        def startswith(self, prefix: Union[Text, Tuple[Text, ...]], start: Optional[int] = ...,
+                       end: Optional[int] = ...) -> bool: ...
+        def strip(self, chars: Optional[str] = ...) -> str: ...
+    else:
+        def startswith(self, prefix: Union[Text, Tuple[Text, ...]]) -> bool: ...
+        @overload
+        def strip(self, chars: str = ...) -> str: ...
+        @overload
+        def strip(self, chars: unicode) -> unicode: ...
+    def swapcase(self) -> str: ...
+    def title(self) -> str: ...
+    if sys.version_info >= (3,):
+        def translate(self, table: Union[Mapping[int, Union[int, str, None]], Sequence[Union[int, str, None]]]) -> str: ...
+    else:
+        def translate(self, table: Optional[AnyStr], deletechars: AnyStr = ...) -> AnyStr: ...
+    def upper(self) -> str: ...
+    def zfill(self, width: int) -> str: ...
+    if sys.version_info >= (3,):
+        @staticmethod
+        @overload
+        def maketrans(x: Union[Dict[int, _T], Dict[str, _T], Dict[Union[str, int], _T]]) -> Dict[int, _T]: ...
+        @staticmethod
+        @overload
+        def maketrans(x: str, y: str, z: str = ...) -> Dict[int, Union[int, None]]: ...
+
+    if sys.version_info >= (3,):
+        def __add__(self, s: str) -> str: ...
+    else:
+        def __add__(self, s: AnyStr) -> AnyStr: ...
+    # Incompatible with Sequence.__contains__
+    def __contains__(self, o: Union[str, Text]) -> bool: ...  # type: ignore
+    def __eq__(self, x: object) -> bool: ...
+    def __ge__(self, x: Text) -> bool: ...
+    def __getitem__(self, i: Union[int, slice]) -> str: ...
+    def __gt__(self, x: Text) -> bool: ...
+    def __hash__(self) -> int: ...
+    def __iter__(self) -> Iterator[str]: ...
+    def __le__(self, x: Text) -> bool: ...
+    def __len__(self) -> int: ...
+    def __lt__(self, x: Text) -> bool: ...
+    def __mod__(self, x: Any) -> str: ...
+    def __mul__(self, n: int) -> str: ...
+    def __ne__(self, x: object) -> bool: ...
+    def __repr__(self) -> str: ...
+    def __rmul__(self, n: int) -> str: ...
+    def __str__(self) -> str: ...
+    def __getnewargs__(self) -> Tuple[str]: ...
+
+    if sys.version_info < (3,):
+        def __getslice__(self, start: int, stop: int) -> str: ...
+        def __float__(self) -> float: ...
+        def __int__(self) -> int: ...
+
+if sys.version_info >= (3,):
+    class bytes(ByteString):
+        @overload
+        def __init__(self, ints: Iterable[int]) -> None: ...
+        @overload
+        def __init__(self, string: str, encoding: str,
+                     errors: str = ...) -> None: ...
+        @overload
+        def __init__(self, length: int) -> None: ...
+        @overload
+        def __init__(self) -> None: ...
+        @overload
+        def __init__(self, o: SupportsBytes) -> None: ...
+        def capitalize(self) -> bytes: ...
+        def center(self, width: int, fillchar: bytes = ...) -> bytes: ...
+        def count(self, sub: Union[bytes, int], start: Optional[int] = ..., end: Optional[int] = ...) -> int: ...
+        def decode(self, encoding: str = ..., errors: str = ...) -> str: ...
+        def endswith(self, suffix: Union[bytes, Tuple[bytes, ...]]) -> bool: ...
+        def expandtabs(self, tabsize: int = ...) -> bytes: ...
+        def find(self, sub: Union[bytes, int], start: Optional[int] = ..., end: Optional[int] = ...) -> int: ...
+        if sys.version_info >= (3, 5):
+            def hex(self) -> str: ...
+        def index(self, sub: Union[bytes, int], start: Optional[int] = ..., end: Optional[int] = ...) -> int: ...
+        def isalnum(self) -> bool: ...
+        def isalpha(self) -> bool: ...
+        if sys.version_info >= (3, 7):
+            def isascii(self) -> bool: ...
+        def isdigit(self) -> bool: ...
+        def islower(self) -> bool: ...
+        def isspace(self) -> bool: ...
+        def istitle(self) -> bool: ...
+        def isupper(self) -> bool: ...
+        def join(self, iterable: Iterable[Union[ByteString, memoryview]]) -> bytes: ...
+        def ljust(self, width: int, fillchar: bytes = ...) -> bytes: ...
+        def lower(self) -> bytes: ...
+        def lstrip(self, chars: Optional[bytes] = ...) -> bytes: ...
+        def partition(self, sep: bytes) -> Tuple[bytes, bytes, bytes]: ...
+        def replace(self, old: bytes, new: bytes, count: int = ...) -> bytes: ...
+        def rfind(self, sub: Union[bytes, int], start: Optional[int] = ..., end: Optional[int] = ...) -> int: ...
+        def rindex(self, sub: Union[bytes, int], start: Optional[int] = ..., end: Optional[int] = ...) -> int: ...
+        def rjust(self, width: int, fillchar: bytes = ...) -> bytes: ...
+        def rpartition(self, sep: bytes) -> Tuple[bytes, bytes, bytes]: ...
+        def rsplit(self, sep: Optional[bytes] = ..., maxsplit: int = ...) -> List[bytes]: ...
+        def rstrip(self, chars: Optional[bytes] = ...) -> bytes: ...
+        def split(self, sep: Optional[bytes] = ..., maxsplit: int = ...) -> List[bytes]: ...
+        def splitlines(self, keepends: bool = ...) -> List[bytes]: ...
+        def startswith(
+            self,
+            prefix: Union[bytes, Tuple[bytes, ...]],
+            start: Optional[int] = ...,
+            end: Optional[int] = ...,
+        ) -> bool: ...
+        def strip(self, chars: Optional[bytes] = ...) -> bytes: ...
+        def swapcase(self) -> bytes: ...
+        def title(self) -> bytes: ...
+        def translate(self, table: Optional[bytes], delete: bytes = ...) -> bytes: ...
+        def upper(self) -> bytes: ...
+        def zfill(self, width: int) -> bytes: ...
+        @classmethod
+        def fromhex(cls, s: str) -> bytes: ...
+        @classmethod
+        def maketrans(cls, frm: bytes, to: bytes) -> bytes: ...
+
+        def __len__(self) -> int: ...
+        def __iter__(self) -> Iterator[int]: ...
+        def __str__(self) -> str: ...
+        def __repr__(self) -> str: ...
+        def __int__(self) -> int: ...
+        def __float__(self) -> float: ...
+        def __hash__(self) -> int: ...
+        @overload
+        def __getitem__(self, i: int) -> int: ...
+        @overload
+        def __getitem__(self, s: slice) -> bytes: ...
+        def __add__(self, s: bytes) -> bytes: ...
+        def __mul__(self, n: int) -> bytes: ...
+        def __rmul__(self, n: int) -> bytes: ...
+        if sys.version_info >= (3, 5):
+            def __mod__(self, value: Any) -> bytes: ...
+        # Incompatible with Sequence.__contains__
+        def __contains__(self, o: Union[int, bytes]) -> bool: ...  # type: ignore
+        def __eq__(self, x: object) -> bool: ...
+        def __ne__(self, x: object) -> bool: ...
+        def __lt__(self, x: bytes) -> bool: ...
+        def __le__(self, x: bytes) -> bool: ...
+        def __gt__(self, x: bytes) -> bool: ...
+        def __ge__(self, x: bytes) -> bool: ...
+        def __getnewargs__(self) -> Tuple[bytes]: ...
+else:
+    bytes = str
+
+class bytearray(MutableSequence[int], ByteString):
+    if sys.version_info >= (3,):
+        @overload
+        def __init__(self) -> None: ...
+        @overload
+        def __init__(self, ints: Iterable[int]) -> None: ...
+        @overload
+        def __init__(self, string: Text, encoding: Text, errors: Text = ...) -> None: ...
+        @overload
+        def __init__(self, length: int) -> None: ...
+    else:
+        @overload
+        def __init__(self) -> None: ...
+        @overload
+        def __init__(self, ints: Iterable[int]) -> None: ...
+        @overload
+        def __init__(self, string: str) -> None: ...
+        @overload
+        def __init__(self, string: Text, encoding: Text, errors: Text = ...) -> None: ...
+        @overload
+        def __init__(self, length: int) -> None: ...
+    def capitalize(self) -> bytearray: ...
+    def center(self, width: int, fillchar: bytes = ...) -> bytearray: ...
+    if sys.version_info >= (3,):
+        def count(self, sub: Union[bytes, int], start: Optional[int] = ..., end: Optional[int] = ...) -> int: ...
+        def copy(self) -> bytearray: ...
+    else:
+        def count(self, x: str) -> int: ...
+    def decode(self, encoding: Text = ..., errors: Text = ...) -> str: ...
+    def endswith(self, suffix: Union[bytes, Tuple[bytes, ...]]) -> bool: ...
+    def expandtabs(self, tabsize: int = ...) -> bytearray: ...
+    if sys.version_info >= (3,):
+        def find(self, sub: Union[bytes, int], start: Optional[int] = ..., end: Optional[int] = ...) -> int: ...
+        if sys.version_info >= (3, 5):
+            def hex(self) -> str: ...
+        def index(self, sub: Union[bytes, int], start: Optional[int] = ..., end: Optional[int] = ...) -> int: ...
+    else:
+        def find(self, sub: str, start: int = ..., end: int = ...) -> int: ...
+        def index(self, sub: str, start: int = ..., end: int = ...) -> int: ...
+    def insert(self, index: int, object: int) -> None: ...
+    def isalnum(self) -> bool: ...
+    def isalpha(self) -> bool: ...
+    if sys.version_info >= (3, 7):
+        def isascii(self) -> bool: ...
+    def isdigit(self) -> bool: ...
+    def islower(self) -> bool: ...
+    def isspace(self) -> bool: ...
+    def istitle(self) -> bool: ...
+    def isupper(self) -> bool: ...
+    if sys.version_info >= (3,):
+        def join(self, iterable: Iterable[Union[ByteString, memoryview]]) -> bytearray: ...
+        def ljust(self, width: int, fillchar: bytes = ...) -> bytearray: ...
+    else:
+        def join(self, iterable: Iterable[str]) -> bytearray: ...
+        def ljust(self, width: int, fillchar: str = ...) -> bytearray: ...
+    def lower(self) -> bytearray: ...
+    def lstrip(self, chars: Optional[bytes] = ...) -> bytearray: ...
+    def partition(self, sep: bytes) -> Tuple[bytearray, bytearray, bytearray]: ...
+    def replace(self, old: bytes, new: bytes, count: int = ...) -> bytearray: ...
+    if sys.version_info >= (3,):
+        def rfind(self, sub: Union[bytes, int], start: Optional[int] = ..., end: Optional[int] = ...) -> int: ...
+        def rindex(self, sub: Union[bytes, int], start: Optional[int] = ..., end: Optional[int] = ...) -> int: ...
+    else:
+        def rfind(self, sub: bytes, start: int = ..., end: int = ...) -> int: ...
+        def rindex(self, sub: bytes, start: int = ..., end: int = ...) -> int: ...
+    def rjust(self, width: int, fillchar: bytes = ...) -> bytearray: ...
+    def rpartition(self, sep: bytes) -> Tuple[bytearray, bytearray, bytearray]: ...
+    def rsplit(self, sep: Optional[bytes] = ..., maxsplit: int = ...) -> List[bytearray]: ...
+    def rstrip(self, chars: Optional[bytes] = ...) -> bytearray: ...
+    def split(self, sep: Optional[bytes] = ..., maxsplit: int = ...) -> List[bytearray]: ...
+    def splitlines(self, keepends: bool = ...) -> List[bytearray]: ...
+    def startswith(
+        self,
+        prefix: Union[bytes, Tuple[bytes, ...]],
+        start: Optional[int] = ...,
+        end: Optional[int] = ...,
+    ) -> bool: ...
+    def strip(self, chars: Optional[bytes] = ...) -> bytearray: ...
+    def swapcase(self) -> bytearray: ...
+    def title(self) -> bytearray: ...
+    if sys.version_info >= (3,):
+        def translate(self, table: Optional[bytes], delete: bytes = ...) -> bytearray: ...
+    else:
+        def translate(self, table: str) -> bytearray: ...
+    def upper(self) -> bytearray: ...
+    def zfill(self, width: int) -> bytearray: ...
+    @staticmethod
+    def fromhex(s: str) -> bytearray: ...
+    if sys.version_info >= (3,):
+        @classmethod
+        def maketrans(cls, frm: bytes, to: bytes) -> bytes: ...
+
+    def __len__(self) -> int: ...
+    def __iter__(self) -> Iterator[int]: ...
+    def __str__(self) -> str: ...
+    def __repr__(self) -> str: ...
+    def __int__(self) -> int: ...
+    def __float__(self) -> float: ...
+    def __hash__(self) -> int: ...
+    @overload
+    def __getitem__(self, i: int) -> int: ...
+    @overload
+    def __getitem__(self, s: slice) -> bytearray: ...
+    @overload
+    def __setitem__(self, i: int, x: int) -> None: ...
+    @overload
+    def __setitem__(self, s: slice, x: Union[Iterable[int], bytes]) -> None: ...
+    def __delitem__(self, i: Union[int, slice]) -> None: ...
+    if sys.version_info < (3,):
+        def __getslice__(self, start: int, stop: int) -> bytearray: ...
+        def __setslice__(self, start: int, stop: int, x: Union[Sequence[int], str]) -> None: ...
+        def __delslice__(self, start: int, stop: int) -> None: ...
+    def __add__(self, s: bytes) -> bytearray: ...
+    if sys.version_info >= (3,):
+        def __iadd__(self, s: Iterable[int]) -> bytearray: ...
+    def __mul__(self, n: int) -> bytearray: ...
+    if sys.version_info >= (3,):
+        def __rmul__(self, n: int) -> bytearray: ...
+        def __imul__(self, n: int) -> bytearray: ...
+    if sys.version_info >= (3, 5):
+        def __mod__(self, value: Any) -> bytes: ...
+    # Incompatible with Sequence.__contains__
+    def __contains__(self, o: Union[int, bytes]) -> bool: ...  # type: ignore
+    def __eq__(self, x: object) -> bool: ...
+    def __ne__(self, x: object) -> bool: ...
+    def __lt__(self, x: bytes) -> bool: ...
+    def __le__(self, x: bytes) -> bool: ...
+    def __gt__(self, x: bytes) -> bool: ...
+    def __ge__(self, x: bytes) -> bool: ...
+
+if sys.version_info >= (3,):
+    _mv_container_type = int
+else:
+    _mv_container_type = str
+
+class memoryview(Sized, Container[_mv_container_type]):
+    format: str
+    itemsize: int
+    shape: Optional[Tuple[int, ...]]
+    strides: Optional[Tuple[int, ...]]
+    suboffsets: Optional[Tuple[int, ...]]
+    readonly: bool
+    ndim: int
+
+    if sys.version_info >= (3,):
+        c_contiguous: bool
+        f_contiguous: bool
+        contiguous: bool
+        def __init__(self, obj: Union[bytes, bytearray, memoryview]) -> None: ...
+        def __enter__(self) -> memoryview: ...
+        def __exit__(self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType]) -> bool: ...
+    else:
+        def __init__(self, obj: Union[bytes, bytearray, buffer, memoryview]) -> None: ...
+
+    @overload
+    def __getitem__(self, i: int) -> _mv_container_type: ...
+    @overload
+    def __getitem__(self, s: slice) -> memoryview: ...
+
+    def __contains__(self, x: object) -> bool: ...
+    def __iter__(self) -> Iterator[_mv_container_type]: ...
+    def __len__(self) -> int: ...
+
+    @overload
+    def __setitem__(self, i: int, o: bytes) -> None: ...
+    @overload
+    def __setitem__(self, s: slice, o: Sequence[bytes]) -> None: ...
+    @overload
+    def __setitem__(self, s: slice, o: memoryview) -> None: ...
+
+    def tobytes(self) -> bytes: ...
+    def tolist(self) -> List[int]: ...
+
+    if sys.version_info >= (3, 5):
+        def hex(self) -> str: ...
+
+class bool(int):
+    def __init__(self, o: object = ...) -> None: ...
+    @overload
+    def __and__(self, x: bool) -> bool: ...
+    @overload
+    def __and__(self, x: int) -> int: ...
+    @overload
+    def __or__(self, x: bool) -> bool: ...
+    @overload
+    def __or__(self, x: int) -> int: ...
+    @overload
+    def __xor__(self, x: bool) -> bool: ...
+    @overload
+    def __xor__(self, x: int) -> int: ...
+    @overload
+    def __rand__(self, x: bool) -> bool: ...
+    @overload
+    def __rand__(self, x: int) -> int: ...
+    @overload
+    def __ror__(self, x: bool) -> bool: ...
+    @overload
+    def __ror__(self, x: int) -> int: ...
+    @overload
+    def __rxor__(self, x: bool) -> bool: ...
+    @overload
+    def __rxor__(self, x: int) -> int: ...
+    def __getnewargs__(self) -> Tuple[int]: ...
+
+class slice(object):
+    start: Optional[int]
+    step: Optional[int]
+    stop: Optional[int]
+    @overload
+    def __init__(self, stop: Optional[int]) -> None: ...
+    @overload
+    def __init__(self, start: Optional[int], stop: Optional[int], step: Optional[int] = ...) -> None: ...
+    def indices(self, len: int) -> Tuple[int, int, int]: ...
+
+class tuple(Sequence[_T_co], Generic[_T_co]):
+    def __new__(cls: Type[_T], iterable: Iterable[_T_co] = ...) -> _T: ...
+    def __init__(self, iterable: Iterable[_T_co] = ...): ...
+    def __len__(self) -> int: ...
+    def __contains__(self, x: object) -> bool: ...
+    @overload
+    def __getitem__(self, x: int) -> _T_co: ...
+    @overload
+    def __getitem__(self, x: slice) -> Tuple[_T_co, ...]: ...
+    def __iter__(self) -> Iterator[_T_co]: ...
+    def __lt__(self, x: Tuple[_T_co, ...]) -> bool: ...
+    def __le__(self, x: Tuple[_T_co, ...]) -> bool: ...
+    def __gt__(self, x: Tuple[_T_co, ...]) -> bool: ...
+    def __ge__(self, x: Tuple[_T_co, ...]) -> bool: ...
+    def __add__(self, x: Tuple[_T_co, ...]) -> Tuple[_T_co, ...]: ...
+    def __mul__(self, n: int) -> Tuple[_T_co, ...]: ...
+    def __rmul__(self, n: int) -> Tuple[_T_co, ...]: ...
+    def count(self, x: Any) -> int: ...
+    if sys.version_info >= (3, 5):
+        def index(self, x: Any, start: int = ..., end: int = ...) -> int: ...
+    else:
+        def index(self, x: Any) -> int: ...
+
+class list(MutableSequence[_T], Generic[_T]):
+    @overload
+    def __init__(self) -> None: ...
+    @overload
+    def __init__(self, iterable: Iterable[_T]) -> None: ...
+    if sys.version_info >= (3,):
+        def clear(self) -> None: ...
+        def copy(self) -> List[_T]: ...
+    def append(self, object: _T) -> None: ...
+    def extend(self, iterable: Iterable[_T]) -> None: ...
+    def pop(self, index: int = ...) -> _T: ...
+    def index(self, object: _T, start: int = ..., stop: int = ...) -> int: ...
+    def count(self, object: _T) -> int: ...
+    def insert(self, index: int, object: _T) -> None: ...
+    def remove(self, object: _T) -> None: ...
+    def reverse(self) -> None: ...
+    if sys.version_info >= (3,):
+        def sort(self, *, key: Optional[Callable[[_T], Any]] = ..., reverse: bool = ...) -> None: ...
+    else:
+        def sort(self, cmp: Callable[[_T, _T], Any] = ..., key: Callable[[_T], Any] = ..., reverse: bool = ...) -> None: ...
+
+    def __len__(self) -> int: ...
+    def __iter__(self) -> Iterator[_T]: ...
+    def __str__(self) -> str: ...
+    def __hash__(self) -> int: ...
+    @overload
+    def __getitem__(self, i: int) -> _T: ...
+    @overload
+    def __getitem__(self, s: slice) -> List[_T]: ...
+    @overload
+    def __setitem__(self, i: int, o: _T) -> None: ...
+    @overload
+    def __setitem__(self, s: slice, o: Iterable[_T]) -> None: ...
+    def __delitem__(self, i: Union[int, slice]) -> None: ...
+    if sys.version_info < (3,):
+        def __getslice__(self, start: int, stop: int) -> List[_T]: ...
+        def __setslice__(self, start: int, stop: int, o: Sequence[_T]) -> None: ...
+        def __delslice__(self, start: int, stop: int) -> None: ...
+    def __add__(self, x: List[_T]) -> List[_T]: ...
+    def __iadd__(self: _S, x: Iterable[_T]) -> _S: ...
+    def __mul__(self, n: int) -> List[_T]: ...
+    def __rmul__(self, n: int) -> List[_T]: ...
+    if sys.version_info >= (3,):
+        def __imul__(self: _S, n: int) -> _S: ...
+    def __contains__(self, o: object) -> bool: ...
+    def __reversed__(self) -> Iterator[_T]: ...
+    def __gt__(self, x: List[_T]) -> bool: ...
+    def __ge__(self, x: List[_T]) -> bool: ...
+    def __lt__(self, x: List[_T]) -> bool: ...
+    def __le__(self, x: List[_T]) -> bool: ...
+
+class dict(MutableMapping[_KT, _VT], Generic[_KT, _VT]):
+    # NOTE: Keyword arguments are special. If they are used, _KT must include
+    #       str, but we have no way of enforcing it here.
+    @overload
+    def __init__(self, **kwargs: _VT) -> None: ...
+    @overload
+    def __init__(self, map: Mapping[_KT, _VT], **kwargs: _VT) -> None: ...
+    @overload
+    def __init__(self, iterable: Iterable[Tuple[_KT, _VT]], **kwargs: _VT) -> None: ...
+
+    def __new__(cls: Type[_T1], *args: Any, **kwargs: Any) -> _T1: ...
+
+    if sys.version_info < (3,):
+        def has_key(self, k: _KT) -> bool: ...
+    def clear(self) -> None: ...
+    def copy(self) -> Dict[_KT, _VT]: ...
+    def popitem(self) -> Tuple[_KT, _VT]: ...
+    def setdefault(self, k: _KT, default: _VT = ...) -> _VT: ...
+    @overload
+    def update(self, __m: Mapping[_KT, _VT], **kwargs: _VT) -> None: ...
+    @overload
+    def update(self, __m: Iterable[Tuple[_KT, _VT]], **kwargs: _VT) -> None: ...
+    @overload
+    def update(self, **kwargs: _VT) -> None: ...
+    if sys.version_info >= (3,):
+        def keys(self) -> KeysView[_KT]: ...
+        def values(self) -> ValuesView[_VT]: ...
+        def items(self) -> ItemsView[_KT, _VT]: ...
+    else:
+        def iterkeys(self) -> Iterator[_KT]: ...
+        def itervalues(self) -> Iterator[_VT]: ...
+        def iteritems(self) -> Iterator[Tuple[_KT, _VT]]: ...
+        def viewkeys(self) -> KeysView[_KT]: ...
+        def viewvalues(self) -> ValuesView[_VT]: ...
+        def viewitems(self) -> ItemsView[_KT, _VT]: ...
+    @staticmethod
+    @overload
+    def fromkeys(seq: Iterable[_T]) -> Dict[_T, Any]: ...  # TODO: Actually a class method (mypy/issues#328)
+    @staticmethod
+    @overload
+    def fromkeys(seq: Iterable[_T], value: _S) -> Dict[_T, _S]: ...
+    def __len__(self) -> int: ...
+    def __getitem__(self, k: _KT) -> _VT: ...
+    def __setitem__(self, k: _KT, v: _VT) -> None: ...
+    def __delitem__(self, v: _KT) -> None: ...
+    def __iter__(self) -> Iterator[_KT]: ...
+    def __str__(self) -> str: ...
+
+class set(MutableSet[_T], Generic[_T]):
+    def __init__(self, iterable: Iterable[_T] = ...) -> None: ...
+    def add(self, element: _T) -> None: ...
+    def clear(self) -> None: ...
+    def copy(self) -> Set[_T]: ...
+    def difference(self, *s: Iterable[Any]) -> Set[_T]: ...
+    def difference_update(self, *s: Iterable[Any]) -> None: ...
+    def discard(self, element: _T) -> None: ...
+    def intersection(self, *s: Iterable[Any]) -> Set[_T]: ...
+    def intersection_update(self, *s: Iterable[Any]) -> None: ...
+    def isdisjoint(self, s: Iterable[Any]) -> bool: ...
+    def issubset(self, s: Iterable[Any]) -> bool: ...
+    def issuperset(self, s: Iterable[Any]) -> bool: ...
+    def pop(self) -> _T: ...
+    def remove(self, element: _T) -> None: ...
+    def symmetric_difference(self, s: Iterable[_T]) -> Set[_T]: ...
+    def symmetric_difference_update(self, s: Iterable[_T]) -> None: ...
+    def union(self, *s: Iterable[_T]) -> Set[_T]: ...
+    def update(self, *s: Iterable[_T]) -> None: ...
+    def __len__(self) -> int: ...
+    def __contains__(self, o: object) -> bool: ...
+    def __iter__(self) -> Iterator[_T]: ...
+    def __str__(self) -> str: ...
+    def __and__(self, s: AbstractSet[object]) -> Set[_T]: ...
+    def __iand__(self, s: AbstractSet[object]) -> Set[_T]: ...
+    def __or__(self, s: AbstractSet[_S]) -> Set[Union[_T, _S]]: ...
+    def __ior__(self, s: AbstractSet[_S]) -> Set[Union[_T, _S]]: ...
+    def __sub__(self, s: AbstractSet[object]) -> Set[_T]: ...
+    def __isub__(self, s: AbstractSet[object]) -> Set[_T]: ...
+    def __xor__(self, s: AbstractSet[_S]) -> Set[Union[_T, _S]]: ...
+    def __ixor__(self, s: AbstractSet[_S]) -> Set[Union[_T, _S]]: ...
+    def __le__(self, s: AbstractSet[object]) -> bool: ...
+    def __lt__(self, s: AbstractSet[object]) -> bool: ...
+    def __ge__(self, s: AbstractSet[object]) -> bool: ...
+    def __gt__(self, s: AbstractSet[object]) -> bool: ...
+
+class frozenset(AbstractSet[_T], Generic[_T]):
+    def __init__(self, iterable: Iterable[_T] = ...) -> None: ...
+    def copy(self) -> FrozenSet[_T]: ...
+    def difference(self, *s: Iterable[object]) -> FrozenSet[_T]: ...
+    def intersection(self, *s: Iterable[object]) -> FrozenSet[_T]: ...
+    def isdisjoint(self, s: Iterable[_T]) -> bool: ...
+    def issubset(self, s: Iterable[object]) -> bool: ...
+    def issuperset(self, s: Iterable[object]) -> bool: ...
+    def symmetric_difference(self, s: Iterable[_T]) -> FrozenSet[_T]: ...
+    def union(self, *s: Iterable[_T]) -> FrozenSet[_T]: ...
+    def __len__(self) -> int: ...
+    def __contains__(self, o: object) -> bool: ...
+    def __iter__(self) -> Iterator[_T]: ...
+    def __str__(self) -> str: ...
+    def __and__(self, s: AbstractSet[_T]) -> FrozenSet[_T]: ...
+    def __or__(self, s: AbstractSet[_S]) -> FrozenSet[Union[_T, _S]]: ...
+    def __sub__(self, s: AbstractSet[_T]) -> FrozenSet[_T]: ...
+    def __xor__(self, s: AbstractSet[_S]) -> FrozenSet[Union[_T, _S]]: ...
+    def __le__(self, s: AbstractSet[object]) -> bool: ...
+    def __lt__(self, s: AbstractSet[object]) -> bool: ...
+    def __ge__(self, s: AbstractSet[object]) -> bool: ...
+    def __gt__(self, s: AbstractSet[object]) -> bool: ...
+
+class enumerate(Iterator[Tuple[int, _T]], Generic[_T]):
+    def __init__(self, iterable: Iterable[_T], start: int = ...) -> None: ...
+    def __iter__(self) -> Iterator[Tuple[int, _T]]: ...
+    if sys.version_info >= (3,):
+        def __next__(self) -> Tuple[int, _T]: ...
+    else:
+        def next(self) -> Tuple[int, _T]: ...
+
+if sys.version_info >= (3,):
+    class range(Sequence[int]):
+        start: int
+        stop: int
+        step: int
+        @overload
+        def __init__(self, stop: int) -> None: ...
+        @overload
+        def __init__(self, start: int, stop: int, step: int = ...) -> None: ...
+        def count(self, value: int) -> int: ...
+        def index(self, value: int, start: int = ..., stop: Optional[int] = ...) -> int: ...
+        def __len__(self) -> int: ...
+        def __contains__(self, o: object) -> bool: ...
+        def __iter__(self) -> Iterator[int]: ...
+        @overload
+        def __getitem__(self, i: int) -> int: ...
+        @overload
+        def __getitem__(self, s: slice) -> range: ...
+        def __repr__(self) -> str: ...
+        def __reversed__(self) -> Iterator[int]: ...
+else:
+    class xrange(Sized, Iterable[int], Reversible[int]):
+        @overload
+        def __init__(self, stop: int) -> None: ...
+        @overload
+        def __init__(self, start: int, stop: int, step: int = ...) -> None: ...
+        def __len__(self) -> int: ...
+        def __iter__(self) -> Iterator[int]: ...
+        def __getitem__(self, i: int) -> int: ...
+        def __reversed__(self) -> Iterator[int]: ...
+
+class property(object):
+    def __init__(self, fget: Optional[Callable[[Any], Any]] = ...,
+                 fset: Optional[Callable[[Any, Any], None]] = ...,
+                 fdel: Optional[Callable[[Any], None]] = ...,
+                 doc: Optional[str] = ...) -> None: ...
+    def getter(self, fget: Callable[[Any], Any]) -> property: ...
+    def setter(self, fset: Callable[[Any, Any], None]) -> property: ...
+    def deleter(self, fdel: Callable[[Any], None]) -> property: ...
+    def __get__(self, obj: Any, type: Optional[type] = ...) -> Any: ...
+    def __set__(self, obj: Any, value: Any) -> None: ...
+    def __delete__(self, obj: Any) -> None: ...
+    def fget(self) -> Any: ...
+    def fset(self, value: Any) -> None: ...
+    def fdel(self) -> None: ...
+
+if sys.version_info < (3,):
+    long = int
+
+NotImplemented: Any
+
+def abs(__n: SupportsAbs[_T]) -> _T: ...
+def all(__i: Iterable[object]) -> bool: ...
+def any(__i: Iterable[object]) -> bool: ...
+if sys.version_info < (3,):
+    def apply(__func: Callable[..., _T], __args: Optional[Sequence[Any]] = ..., __kwds: Optional[Mapping[str, Any]] = ...) -> _T: ...
+if sys.version_info >= (3,):
+    def ascii(__o: object) -> str: ...
+
+class _SupportsIndex(Protocol):
+    def __index__(self) -> int: ...
+def bin(__number: Union[int, _SupportsIndex]) -> str: ...
+
+if sys.version_info >= (3, 7):
+    def breakpoint(*args: Any, **kws: Any) -> None: ...
+def callable(__o: object) -> bool: ...
+def chr(__code: int) -> str: ...
+if sys.version_info < (3,):
+    def cmp(__x: Any, __y: Any) -> int: ...
+    _N1 = TypeVar('_N1', bool, int, float, complex)
+    def coerce(__x: _N1, __y: _N1) -> Tuple[_N1, _N1]: ...
+if sys.version_info >= (3, 6):
+    # This class is to be exported as PathLike from os,
+    # but we define it here as _PathLike to avoid import cycle issues.
+    # See https://github.com/python/typeshed/pull/991#issuecomment-288160993
+    class _PathLike(Generic[AnyStr]):
+        def __fspath__(self) -> AnyStr: ...
+    def compile(source: Union[str, bytes, mod, AST], filename: Union[str, bytes, _PathLike], mode: str, flags: int = ..., dont_inherit: int = ..., optimize: int = ...) -> Any: ...
+elif sys.version_info >= (3,):
+    def compile(source: Union[str, bytes, mod, AST], filename: Union[str, bytes], mode: str, flags: int = ..., dont_inherit: int = ..., optimize: int = ...) -> Any: ...
+else:
+    def compile(source: Union[Text, mod], filename: Text, mode: Text, flags: int = ..., dont_inherit: int = ...) -> Any: ...
+if sys.version_info >= (3,):
+    def copyright() -> None: ...
+    def credits() -> None: ...
+def delattr(__o: Any, __name: Text) -> None: ...
+def dir(__o: object = ...) -> List[str]: ...
+_N2 = TypeVar('_N2', int, float)
+def divmod(__a: _N2, __b: _N2) -> Tuple[_N2, _N2]: ...
+def eval(__source: Union[Text, bytes, CodeType], __globals: Optional[Dict[str, Any]] = ..., __locals: Optional[Mapping[str, Any]] = ...) -> Any: ...
+if sys.version_info >= (3,):
+    def exec(__object: Union[str, bytes, CodeType], __globals: Optional[Dict[str, Any]] = ..., __locals: Optional[Mapping[str, Any]] = ...) -> Any: ...
+else:
+    def execfile(__filename: str, __globals: Optional[Dict[str, Any]] = ..., __locals: Optional[Dict[str, Any]] = ...) -> None: ...
+def exit(code: object = ...) -> NoReturn: ...
+if sys.version_info >= (3,):
+    @overload
+    def filter(__function: None, __iterable: Iterable[Optional[_T]]) -> Iterator[_T]: ...
+    @overload
+    def filter(__function: Callable[[_T], Any], __iterable: Iterable[_T]) -> Iterator[_T]: ...
+else:
+    @overload
+    def filter(__function: Callable[[AnyStr], Any],  # type: ignore
+               __iterable: AnyStr) -> AnyStr: ...
+    @overload
+    def filter(__function: None,  # type: ignore
+               __iterable: Tuple[Optional[_T], ...]) -> Tuple[_T, ...]: ...
+    @overload
+    def filter(__function: Callable[[_T], Any],  # type: ignore
+               __iterable: Tuple[_T, ...]) -> Tuple[_T, ...]: ...
+    @overload
+    def filter(__function: None,
+               __iterable: Iterable[Optional[_T]]) -> List[_T]: ...
+    @overload
+    def filter(__function: Callable[[_T], Any],
+               __iterable: Iterable[_T]) -> List[_T]: ...
+def format(__o: object, __format_spec: str = ...) -> str: ...  # TODO unicode
+def getattr(__o: Any, name: Text, __default: Any = ...) -> Any: ...
+def globals() -> Dict[str, Any]: ...
+def hasattr(__o: Any, __name: Text) -> bool: ...
+def hash(__o: object) -> int: ...
+if sys.version_info >= (3,):
+    def help(*args: Any, **kwds: Any) -> None: ...
+def hex(__i: Union[int, _SupportsIndex]) -> str: ...
+def id(__o: object) -> int: ...
+if sys.version_info >= (3,):
+    def input(__prompt: Any = ...) -> str: ...
+else:
+    def input(__prompt: Any = ...) -> Any: ...
+    def intern(__string: str) -> str: ...
+@overload
+def iter(__iterable: Iterable[_T]) -> Iterator[_T]: ...
+@overload
+def iter(__function: Callable[[], _T], __sentinel: _T) -> Iterator[_T]: ...
+def isinstance(__o: object, __t: Union[type, Tuple[Union[type, Tuple], ...]]) -> bool: ...
+def issubclass(__cls: type, __classinfo: Union[type, Tuple[Union[type, Tuple], ...]]) -> bool: ...
+def len(__o: Sized) -> int: ...
+if sys.version_info >= (3,):
+    def license() -> None: ...
+def locals() -> Dict[str, Any]: ...
+if sys.version_info >= (3,):
+    @overload
+    def map(__func: Callable[[_T1], _S], __iter1: Iterable[_T1]) -> Iterator[_S]: ...
+    @overload
+    def map(__func: Callable[[_T1, _T2], _S], __iter1: Iterable[_T1],
+            __iter2: Iterable[_T2]) -> Iterator[_S]: ...
+    @overload
+    def map(__func: Callable[[_T1, _T2, _T3], _S],
+            __iter1: Iterable[_T1],
+            __iter2: Iterable[_T2],
+            __iter3: Iterable[_T3]) -> Iterator[_S]: ...
+    @overload
+    def map(__func: Callable[[_T1, _T2, _T3, _T4], _S],
+            __iter1: Iterable[_T1],
+            __iter2: Iterable[_T2],
+            __iter3: Iterable[_T3],
+            __iter4: Iterable[_T4]) -> Iterator[_S]: ...
+    @overload
+    def map(__func: Callable[[_T1, _T2, _T3, _T4, _T5], _S],
+            __iter1: Iterable[_T1],
+            __iter2: Iterable[_T2],
+            __iter3: Iterable[_T3],
+            __iter4: Iterable[_T4],
+            __iter5: Iterable[_T5]) -> Iterator[_S]: ...
+    @overload
+    def map(__func: Callable[..., _S],
+            __iter1: Iterable[Any],
+            __iter2: Iterable[Any],
+            __iter3: Iterable[Any],
+            __iter4: Iterable[Any],
+            __iter5: Iterable[Any],
+            __iter6: Iterable[Any],
+            *iterables: Iterable[Any]) -> Iterator[_S]: ...
+else:
+    @overload
+    def map(__func: None, __iter1: Iterable[_T1]) -> List[_T1]: ...
+    @overload
+    def map(__func: None,
+            __iter1: Iterable[_T1],
+            __iter2: Iterable[_T2]) -> List[Tuple[_T1, _T2]]: ...
+    @overload
+    def map(__func: None,
+            __iter1: Iterable[_T1],
+            __iter2: Iterable[_T2],
+            __iter3: Iterable[_T3]) -> List[Tuple[_T1, _T2, _T3]]: ...
+    @overload
+    def map(__func: None,
+            __iter1: Iterable[_T1],
+            __iter2: Iterable[_T2],
+            __iter3: Iterable[_T3],
+            __iter4: Iterable[_T4]) -> List[Tuple[_T1, _T2, _T3, _T4]]: ...
+    @overload
+    def map(__func: None,
+            __iter1: Iterable[_T1],
+            __iter2: Iterable[_T2],
+            __iter3: Iterable[_T3],
+            __iter4: Iterable[_T4],
+            __iter5: Iterable[_T5]) -> List[Tuple[_T1, _T2, _T3, _T4, _T5]]: ...
+    @overload
+    def map(__func: None,
+            __iter1: Iterable[Any],
+            __iter2: Iterable[Any],
+            __iter3: Iterable[Any],
+            __iter4: Iterable[Any],
+            __iter5: Iterable[Any],
+            __iter6: Iterable[Any],
+            *iterables: Iterable[Any]) -> List[Tuple[Any, ...]]: ...
+    @overload
+    def map(__func: Callable[[_T1], _S], __iter1: Iterable[_T1]) -> List[_S]: ...
+    @overload
+    def map(__func: Callable[[_T1, _T2], _S],
+            __iter1: Iterable[_T1],
+            __iter2: Iterable[_T2]) -> List[_S]: ...
+    @overload
+    def map(__func: Callable[[_T1, _T2, _T3], _S],
+            __iter1: Iterable[_T1],
+            __iter2: Iterable[_T2],
+            __iter3: Iterable[_T3]) -> List[_S]: ...
+    @overload
+    def map(__func: Callable[[_T1, _T2, _T3, _T4], _S],
+            __iter1: Iterable[_T1],
+            __iter2: Iterable[_T2],
+            __iter3: Iterable[_T3],
+            __iter4: Iterable[_T4]) -> List[_S]: ...
+    @overload
+    def map(__func: Callable[[_T1, _T2, _T3, _T4, _T5], _S],
+            __iter1: Iterable[_T1],
+            __iter2: Iterable[_T2],
+            __iter3: Iterable[_T3],
+            __iter4: Iterable[_T4],
+            __iter5: Iterable[_T5]) -> List[_S]: ...
+    @overload
+    def map(__func: Callable[..., _S],
+            __iter1: Iterable[Any],
+            __iter2: Iterable[Any],
+            __iter3: Iterable[Any],
+            __iter4: Iterable[Any],
+            __iter5: Iterable[Any],
+            __iter6: Iterable[Any],
+            *iterables: Iterable[Any]) -> List[_S]: ...
+if sys.version_info >= (3,):
+    @overload
+    def max(__arg1: _T, __arg2: _T, *_args: _T, key: Callable[[_T], Any] = ...) -> _T: ...
+    @overload
+    def max(__iterable: Iterable[_T], *, key: Callable[[_T], Any] = ...) -> _T: ...
+    @overload
+    def max(__iterable: Iterable[_T], *, key: Callable[[_T], Any] = ..., default: _VT) -> Union[_T, _VT]: ...
+else:
+    @overload
+    def max(__arg1: _T, __arg2: _T, *_args: _T, key: Callable[[_T], Any] = ...) -> _T: ...
+    @overload
+    def max(__iterable: Iterable[_T], *, key: Callable[[_T], Any] = ...) -> _T: ...
+if sys.version_info >= (3,):
+    @overload
+    def min(__arg1: _T, __arg2: _T, *_args: _T, key: Callable[[_T], Any] = ...) -> _T: ...
+    @overload
+    def min(__iterable: Iterable[_T], *, key: Callable[[_T], Any] = ...) -> _T: ...
+    @overload
+    def min(__iterable: Iterable[_T], *, key: Callable[[_T], Any] = ..., default: _VT) -> Union[_T, _VT]: ...
+else:
+    @overload
+    def min(__arg1: _T, __arg2: _T, *_args: _T, key: Callable[[_T], Any] = ...) -> _T: ...
+    @overload
+    def min(__iterable: Iterable[_T], *, key: Callable[[_T], Any] = ...) -> _T: ...
+@overload
+def next(__i: Iterator[_T]) -> _T: ...
+@overload
+def next(__i: Iterator[_T], default: _VT) -> Union[_T, _VT]: ...
+def oct(__i: Union[int, _SupportsIndex]) -> str: ...
+
+if sys.version_info >= (3, 6):
+    def open(file: Union[str, bytes, int, _PathLike], mode: str = ..., buffering: int = ..., encoding: Optional[str] = ...,
+             errors: Optional[str] = ..., newline: Optional[str] = ..., closefd: bool = ...,
+             opener: Optional[Callable[[str, int], int]] = ...) -> IO[Any]: ...
+elif sys.version_info >= (3,):
+    def open(file: Union[str, bytes, int], mode: str = ..., buffering: int = ..., encoding: Optional[str] = ...,
+             errors: Optional[str] = ..., newline: Optional[str] = ..., closefd: bool = ...,
+             opener: Optional[Callable[[str, int], int]] = ...) -> IO[Any]: ...
+else:
+    def open(name: Union[unicode, int], mode: unicode = ..., buffering: int = ...) -> BinaryIO: ...
+
+def ord(__c: Union[Text, bytes]) -> int: ...
+if sys.version_info >= (3,):
+    class _Writer(Protocol):
+        def write(self, __s: str) -> Any: ...
+    def print(*values: object, sep: Text = ..., end: Text = ..., file: Optional[_Writer] = ..., flush: bool = ...) -> None: ...
+else:
+    class _Writer(Protocol):
+        def write(self, __s: Any) -> Any: ...
+    # This is only available after from __future__ import print_function.
+    def print(*values: object, sep: Text = ..., end: Text = ..., file: Optional[_Writer] = ...) -> None: ...
+@overload
+def pow(__x: int, __y: int) -> Any: ...  # The return type can be int or float, depending on y
+@overload
+def pow(__x: int, __y: int, __z: int) -> Any: ...
+@overload
+def pow(__x: float, __y: float) -> float: ...
+@overload
+def pow(__x: float, __y: float, __z: float) -> float: ...
+def quit(code: object = ...) -> NoReturn: ...
+if sys.version_info < (3,):
+    def range(__x: int, __y: int = ..., __step: int = ...) -> List[int]: ...
+    def raw_input(__prompt: Any = ...) -> str: ...
+    @overload
+    def reduce(__function: Callable[[_T, _S], _T], __iterable: Iterable[_S], __initializer: _T) -> _T: ...
+    @overload
+    def reduce(__function: Callable[[_T, _T], _T], __iterable: Iterable[_T]) -> _T: ...
+    def reload(__module: Any) -> Any: ...
+@overload
+def reversed(__object: Sequence[_T]) -> Iterator[_T]: ...
+@overload
+def reversed(__object: Reversible[_T]) -> Iterator[_T]: ...
+def repr(__o: object) -> str: ...
+if sys.version_info >= (3,):
+    @overload
+    def round(number: float) -> int: ...
+    @overload
+    def round(number: float, ndigits: None) -> int: ...
+    @overload
+    def round(number: float, ndigits: int) -> float: ...
+    @overload
+    def round(number: SupportsRound[_T]) -> int: ...
+    @overload
+    def round(number: SupportsRound[_T], ndigits: None) -> int: ...  # type: ignore
+    @overload
+    def round(number: SupportsRound[_T], ndigits: int) -> _T: ...
+else:
+    @overload
+    def round(number: float) -> float: ...
+    @overload
+    def round(number: float, ndigits: int) -> float: ...
+    @overload
+    def round(number: SupportsFloat) -> float: ...
+    @overload
+    def round(number: SupportsFloat, ndigits: int) -> float: ...
+def setattr(__object: Any, __name: Text, __value: Any) -> None: ...
+if sys.version_info >= (3,):
+    def sorted(__iterable: Iterable[_T], *,
+               key: Optional[Callable[[_T], Any]] = ...,
+               reverse: bool = ...) -> List[_T]: ...
+else:
+    def sorted(__iterable: Iterable[_T], *,
+               cmp: Callable[[_T, _T], int] = ...,
+               key: Callable[[_T], Any] = ...,
+               reverse: bool = ...) -> List[_T]: ...
+@overload
+def sum(__iterable: Iterable[_T]) -> Union[_T, int]: ...
+@overload
+def sum(__iterable: Iterable[_T], __start: _S) -> Union[_T, _S]: ...
+if sys.version_info < (3,):
+    def unichr(__i: int) -> unicode: ...
+def vars(__object: Any = ...) -> Dict[str, Any]: ...
+if sys.version_info >= (3,):
+    @overload
+    def zip(__iter1: Iterable[_T1]) -> Iterator[Tuple[_T1]]: ...
+    @overload
+    def zip(__iter1: Iterable[_T1], __iter2: Iterable[_T2]) -> Iterator[Tuple[_T1, _T2]]: ...
+    @overload
+    def zip(__iter1: Iterable[_T1], __iter2: Iterable[_T2],
+            __iter3: Iterable[_T3]) -> Iterator[Tuple[_T1, _T2, _T3]]: ...
+    @overload
+    def zip(__iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3],
+            __iter4: Iterable[_T4]) -> Iterator[Tuple[_T1, _T2, _T3, _T4]]: ...
+    @overload
+    def zip(__iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3],
+            __iter4: Iterable[_T4], __iter5: Iterable[_T5]) -> Iterator[Tuple[_T1, _T2, _T3, _T4, _T5]]: ...
+    @overload
+    def zip(__iter1: Iterable[Any], __iter2: Iterable[Any], __iter3: Iterable[Any],
+            __iter4: Iterable[Any], __iter5: Iterable[Any], __iter6: Iterable[Any],
+            *iterables: Iterable[Any]) -> Iterator[Tuple[Any, ...]]: ...
+else:
+    @overload
+    def zip(__iter1: Iterable[_T1]) -> List[Tuple[_T1]]: ...
+    @overload
+    def zip(__iter1: Iterable[_T1],
+            __iter2: Iterable[_T2]) -> List[Tuple[_T1, _T2]]: ...
+    @overload
+    def zip(__iter1: Iterable[_T1], __iter2: Iterable[_T2],
+            __iter3: Iterable[_T3]) -> List[Tuple[_T1, _T2, _T3]]: ...
+    @overload
+    def zip(__iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3],
+            __iter4: Iterable[_T4]) -> List[Tuple[_T1, _T2, _T3, _T4]]: ...
+    @overload
+    def zip(__iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3],
+            __iter4: Iterable[_T4], __iter5: Iterable[_T5]) -> List[Tuple[_T1, _T2, _T3, _T4, _T5]]: ...
+    @overload
+    def zip(__iter1: Iterable[Any], __iter2: Iterable[Any], __iter3: Iterable[Any],
+            __iter4: Iterable[Any], __iter5: Iterable[Any], __iter6: Iterable[Any],
+            *iterables: Iterable[Any]) -> List[Tuple[Any, ...]]: ...
+def __import__(name: Text, globals: Dict[str, Any] = ..., locals: Dict[str, Any] = ...,
+               fromlist: List[str] = ..., level: int = ...) -> Any: ...
+
+# Actually the type of Ellipsis is <type 'ellipsis'>, but since it's
+# not exposed anywhere under that name, we make it private here.
+class ellipsis: ...
+Ellipsis: ellipsis
+
+if sys.version_info < (3,):
+    # TODO: buffer support is incomplete; e.g. some_string.startswith(some_buffer) doesn't type check.
+    _AnyBuffer = TypeVar('_AnyBuffer', str, unicode, bytearray, buffer)
+
+    class buffer(Sized):
+        def __init__(self, object: _AnyBuffer, offset: int = ..., size: int = ...) -> None: ...
+        def __add__(self, other: _AnyBuffer) -> str: ...
+        def __cmp__(self, other: _AnyBuffer) -> bool: ...
+        def __getitem__(self, key: Union[int, slice]) -> str: ...
+        def __getslice__(self, i: int, j: int) -> str: ...
+        def __len__(self) -> int: ...
+        def __mul__(self, x: int) -> str: ...
+
+class BaseException(object):
+    args: Tuple[Any, ...]
+    if sys.version_info < (3,):
+        message: Any
+    if sys.version_info >= (3,):
+        __cause__: Optional[BaseException]
+        __context__: Optional[BaseException]
+        __suppress_context__: bool
+        __traceback__: Optional[TracebackType]
+    def __init__(self, *args: object) -> None: ...
+    if sys.version_info < (3,):
+        def __getitem__(self, i: int) -> Any: ...
+        def __getslice__(self, start: int, stop: int) -> Tuple[Any, ...]: ...
+    if sys.version_info >= (3,):
+        def with_traceback(self, tb: Optional[TracebackType]) -> BaseException: ...
+
+class GeneratorExit(BaseException): ...
+class KeyboardInterrupt(BaseException): ...
+class SystemExit(BaseException):
+    code: int
+class Exception(BaseException): ...
+class StopIteration(Exception):
+    if sys.version_info >= (3,):
+        value: Any
+if sys.version_info >= (3,):
+    _StandardError = Exception
+    class OSError(Exception):
+        errno: int
+        strerror: str
+        # filename, filename2 are actually Union[str, bytes, None]
+        filename: Any
+        filename2: Any
+    EnvironmentError = OSError
+    IOError = OSError
+else:
+    class StandardError(Exception): ...
+    _StandardError = StandardError
+    class EnvironmentError(StandardError):
+        errno: int
+        strerror: str
+        # TODO can this be unicode?
+        filename: str
+    class OSError(EnvironmentError): ...
+    class IOError(EnvironmentError): ...
+
+class ArithmeticError(_StandardError): ...
+class AssertionError(_StandardError): ...
+class AttributeError(_StandardError): ...
+class BufferError(_StandardError): ...
+class EOFError(_StandardError): ...
+class ImportError(_StandardError):
+    if sys.version_info >= (3,):
+        name: str
+        path: str
+class LookupError(_StandardError): ...
+class MemoryError(_StandardError): ...
+class NameError(_StandardError): ...
+class ReferenceError(_StandardError): ...
+class RuntimeError(_StandardError): ...
+if sys.version_info >= (3, 5):
+    class StopAsyncIteration(Exception):
+        value: Any
+class SyntaxError(_StandardError):
+    msg: str
+    lineno: int
+    offset: Optional[int]
+    text: str
+    filename: str
+class SystemError(_StandardError): ...
+class TypeError(_StandardError): ...
+class ValueError(_StandardError): ...
+
+class FloatingPointError(ArithmeticError): ...
+class OverflowError(ArithmeticError): ...
+class ZeroDivisionError(ArithmeticError): ...
+
+if sys.version_info >= (3, 6):
+    class ModuleNotFoundError(ImportError): ...
+
+class IndexError(LookupError): ...
+class KeyError(LookupError): ...
+
+class UnboundLocalError(NameError): ...
+
+class WindowsError(OSError):
+    winerror: int
+if sys.version_info >= (3,):
+    class BlockingIOError(OSError):
+        characters_written: int
+    class ChildProcessError(OSError): ...
+    class ConnectionError(OSError): ...
+    class BrokenPipeError(ConnectionError): ...
+    class ConnectionAbortedError(ConnectionError): ...
+    class ConnectionRefusedError(ConnectionError): ...
+    class ConnectionResetError(ConnectionError): ...
+    class FileExistsError(OSError): ...
+    class FileNotFoundError(OSError): ...
+    class InterruptedError(OSError): ...
+    class IsADirectoryError(OSError): ...
+    class NotADirectoryError(OSError): ...
+    class PermissionError(OSError): ...
+    class ProcessLookupError(OSError): ...
+    class TimeoutError(OSError): ...
+
+class NotImplementedError(RuntimeError): ...
+if sys.version_info >= (3, 5):
+    class RecursionError(RuntimeError): ...
+
+class IndentationError(SyntaxError): ...
+class TabError(IndentationError): ...
+
+class UnicodeError(ValueError): ...
+class UnicodeDecodeError(UnicodeError):
+    encoding: str
+    object: bytes
+    start: int
+    end: int
+    reason: str
+    def __init__(self, __encoding: str, __object: bytes, __start: int, __end: int,
+                 __reason: str) -> None: ...
+class UnicodeEncodeError(UnicodeError):
+    encoding: str
+    object: Text
+    start: int
+    end: int
+    reason: str
+    def __init__(self, __encoding: str, __object: Text, __start: int, __end: int,
+                 __reason: str) -> None: ...
+class UnicodeTranslateError(UnicodeError): ...
+
+class Warning(Exception): ...
+class UserWarning(Warning): ...
+class DeprecationWarning(Warning): ...
+class SyntaxWarning(Warning): ...
+class RuntimeWarning(Warning): ...
+class FutureWarning(Warning): ...
+class PendingDeprecationWarning(Warning): ...
+class ImportWarning(Warning): ...
+class UnicodeWarning(Warning): ...
+class BytesWarning(Warning): ...
+if sys.version_info >= (3, 2):
+    class ResourceWarning(Warning): ...
+
+if sys.version_info < (3,):
+    class file(BinaryIO):
+        @overload
+        def __init__(self, file: str, mode: str = ..., buffering: int = ...) -> None: ...
+        @overload
+        def __init__(self, file: unicode, mode: str = ..., buffering: int = ...) -> None: ...
+        @overload
+        def __init__(self, file: int, mode: str = ..., buffering: int = ...) -> None: ...
+        def __iter__(self) -> Iterator[str]: ...
+        def next(self) -> str: ...
+        def read(self, n: int = ...) -> str: ...
+        def __enter__(self) -> BinaryIO: ...
+        def __exit__(self, t: Optional[type] = ..., exc: Optional[BaseException] = ..., tb: Optional[Any] = ...) -> bool: ...
+        def flush(self) -> None: ...
+        def fileno(self) -> int: ...
+        def isatty(self) -> bool: ...
+        def close(self) -> None: ...
+
+        def readable(self) -> bool: ...
+        def writable(self) -> bool: ...
+        def seekable(self) -> bool: ...
+        def seek(self, offset: int, whence: int = ...) -> int: ...
+        def tell(self) -> int: ...
+        def readline(self, limit: int = ...) -> str: ...
+        def readlines(self, hint: int = ...) -> List[str]: ...
+        def write(self, data: str) -> int: ...
+        def writelines(self, data: Iterable[str]) -> None: ...
+        def truncate(self, pos: Optional[int] = ...) -> int: ...