"""# default #"""
class dict:
    def __class__():
      pass
    def __contains__():
      pass
    def __delattr__():
      pass
    def __delitem__():
      pass
    def __dir__():
      pass
    def __doc__():
      pass
    def __eq__():
      pass
    def __format__():
      pass
    def __ge__():
      pass
    def __getattribute__():
      pass
    def __getitem__():
      pass
    def __gt__():
      pass
    def __hash__():
      pass
    def __init__():
      pass
    def __init_subclass__():
      pass
    def __iter__():
      pass
    def __le__():
      pass
    def __len__():
      pass
    def __lt__():
      pass
    def __ne__():
      pass
    def __new__():
      pass
    def __reduce__():
      pass
    def __reduce_ex__():
      pass
    def __repr__():
      pass
    def __reversed__():
      pass
    def __setattr__():
      pass
    def __setitem__():
      pass
    def __sizeof__():
      pass
    def __str__():
      pass
    def __subclasshook__():
      pass
    def clear():
      pass
    def copy():
      pass
    def fromkeys():
      pass
    def get():
      pass
    def items():
      pass
    def keys():
      pass
    def pop():
      pass
    def popitem():
      pass
    def setdefault():
      pass
    def update():
      pass
    def values():
      pass
class list:
    def __add__():
      pass
    def __class__():
      pass
    def __contains__():
      pass
    def __delattr__():
      pass
    def __delitem__():
      pass
    def __dir__():
      pass
    def __doc__():
      pass
    def __eq__():
      pass
    def __format__():
      pass
    def __ge__():
      pass
    def __getattribute__():
      pass
    def __getitem__():
      pass
    def __gt__():
      pass
    def __hash__():
      pass
    def __iadd__():
      pass
    def __imul__():
      pass
    def __init__():
      pass
    def __init_subclass__():
      pass
    def __iter__():
      pass
    def __le__():
      pass
    def __len__():
      pass
    def __lt__():
      pass
    def __mul__():
      pass
    def __ne__():
      pass
    def __new__():
      pass
    def __reduce__():
      pass
    def __reduce_ex__():
      pass
    def __repr__():
      pass
    def __reversed__():
      pass
    def __rmul__():
      pass
    def __setattr__():
      pass
    def __setitem__():
      pass
    def __sizeof__():
      pass
    def __str__():
      pass
    def __subclasshook__():
      pass
    def append():
      pass
    def clear():
      pass
    def copy():
      pass
    def count():
      pass
    def extend():
      pass
    def index():
      pass
    def insert():
      pass
    def pop():
      pass
    def remove():
      pass
    def reverse():
      pass
    def sort():
      pass
class tuple:
    def __add__():
      pass
    def __class__():
      pass
    def __contains__():
      pass
    def __delattr__():
      pass
    def __dir__():
      pass
    def __doc__():
      pass
    def __eq__():
      pass
    def __format__():
      pass
    def __ge__():
      pass
    def __getattribute__():
      pass
    def __getitem__():
      pass
    def __getnewargs__():
      pass
    def __gt__():
      pass
    def __hash__():
      pass
    def __init__():
      pass
    def __init_subclass__():
      pass
    def __iter__():
      pass
    def __le__():
      pass
    def __len__():
      pass
    def __lt__():
      pass
    def __mul__():
      pass
    def __ne__():
      pass
    def __new__():
      pass
    def __reduce__():
      pass
    def __reduce_ex__():
      pass
    def __repr__():
      pass
    def __rmul__():
      pass
    def __setattr__():
      pass
    def __sizeof__():
      pass
    def __str__():
      pass
    def __subclasshook__():
      pass
    def count():
      pass
    def index():
      pass
class str:
    def __add__():
      pass
    def __class__():
      pass
    def __contains__():
      pass
    def __delattr__():
      pass
    def __dir__():
      pass
    def __doc__():
      pass
    def __eq__():
      pass
    def __format__():
      pass
    def __ge__():
      pass
    def __getattribute__():
      pass
    def __getitem__():
      pass
    def __getnewargs__():
      pass
    def __gt__():
      pass
    def __hash__():
      pass
    def __init__():
      pass
    def __init_subclass__():
      pass
    def __iter__():
      pass
    def __le__():
      pass
    def __len__():
      pass
    def __lt__():
      pass
    def __mod__():
      pass
    def __mul__():
      pass
    def __ne__():
      pass
    def __new__():
      pass
    def __reduce__():
      pass
    def __reduce_ex__():
      pass
    def __repr__():
      pass
    def __rmod__():
      pass
    def __rmul__():
      pass
    def __setattr__():
      pass
    def __sizeof__():
      pass
    def __str__():
      pass
    def __subclasshook__():
      pass
    def capitalize():
      pass
    def casefold():
      pass
    def center():
      pass
    def count():
      pass
    def encode():
      pass
    def endswith():
      pass
    def expandtabs():
      pass
    def find():
      pass
    def format():
      pass
    def format_map():
      pass
    def index():
      pass
    def isalnum():
      pass
    def isalpha():
      pass
    def isascii():
      pass
    def isdecimal():
      pass
    def isdigit():
      pass
    def isidentifier():
      pass
    def islower():
      pass
    def isnumeric():
      pass
    def isprintable():
      pass
    def isspace():
      pass
    def istitle():
      pass
    def isupper():
      pass
    def join():
      pass
    def ljust():
      pass
    def lower():
      pass
    def lstrip():
      pass
    def maketrans():
      pass
    def partition():
      pass
    def replace():
      pass
    def rfind():
      pass
    def rindex():
      pass
    def rjust():
      pass
    def rpartition():
      pass
    def rsplit():
      pass
    def rstrip():
      pass
    def split():
      pass
    def splitlines():
      pass
    def startswith():
      pass
    def strip():
      pass
    def swapcase():
      pass
    def title():
      pass
    def translate():
      pass
    def upper():
      pass
    def zfill():
      pass
class property:
    def __class__():
      pass
    def __delattr__():
      pass
    def __delete__():
      pass
    def __dir__():
      pass
    def __doc__():
      pass
    def __eq__():
      pass
    def __format__():
      pass
    def __ge__():
      pass
    def __get__():
      pass
    def __getattribute__():
      pass
    def __gt__():
      pass
    def __hash__():
      pass
    def __init__():
      pass
    def __init_subclass__():
      pass
    def __isabstractmethod__():
      pass
    def __le__():
      pass
    def __lt__():
      pass
    def __ne__():
      pass
    def __new__():
      pass
    def __reduce__():
      pass
    def __reduce_ex__():
      pass
    def __repr__():
      pass
    def __set__():
      pass
    def __setattr__():
      pass
    def __sizeof__():
      pass
    def __str__():
      pass
    def __subclasshook__():
      pass
    def deleter():
      pass
    def fdel():
      pass
    def fget():
      pass
    def fset():
      pass
    def getter():
      pass
    def setter():
      pass
"""# abc.py #"""
def abstractmethod(funcobj):
   pass
        class C(metaclass=ABCMeta):
            def my_abstract_method(self, ...):
                        pass
class abstractclassmethod(classmethod):
    def __init__(self, callable):
        pass
class abstractstaticmethod(staticmethod):
    def __init__(self, callable):
        pass
class abstractproperty(property):
    class ABCMeta(type):
        def __new__(mcls, name, bases, namespace, **kwargs):
                pass
        def register(cls, subclass):
                pass
        def __instancecheck__(cls, instance):
                pass
        def __subclasscheck__(cls, subclass):
                pass
        def _dump_registry(cls, file=None):
                pass
        def _abc_registry_clear(cls):
                pass
        def _abc_caches_clear(cls):
                pass
class ABC(metaclass=ABCMeta):
"""# aifc.py #"""
class Error(Exception):
def _read_long(file):
   pass
def _read_ulong(file):
   pass
def _read_short(file):
   pass
def _read_ushort(file):
   pass
def _read_string(file):
   pass
def _read_float(f): # 10 bytes
   pass
def _write_short(f, x):
   pass
def _write_ushort(f, x):
   pass
def _write_long(f, x):
   pass
def _write_ulong(f, x):
   pass
def _write_string(f, s):
   pass
def _write_float(f, x):
   pass
class Aifc_read:
    def initfp(self, file):
        pass
    def __init__(self, f):
        pass
    def __enter__(self):
        pass
    def __exit__(self, *args):
        pass
    def getfp(self):
        pass
    def rewind(self):
        pass
    def close(self):
        pass
    def tell(self):
        pass
    def getnchannels(self):
        pass
    def getnframes(self):
        pass
    def getsampwidth(self):
        pass
    def getframerate(self):
        pass
    def getcomptype(self):
        pass
    def getcompname(self):
        pass
    def getparams(self):
        pass
    def getmarkers(self):
        pass
    def getmark(self, id):
        pass
    def setpos(self, pos):
        pass
    def readframes(self, nframes):
        pass
    def _read_comm_chunk(self, chunk):
        pass
    def _readmark(self, chunk):
        pass
class Aifc_write:
    def __init__(self, f):
        pass
    def initfp(self, file):
        pass
    def __del__(self):
        pass
    def __enter__(self):
        pass
    def __exit__(self, *args):
        pass
    def aiff(self):
        pass
    def aifc(self):
        pass
    def setnchannels(self, nchannels):
        pass
    def getnchannels(self):
        pass
    def setsampwidth(self, sampwidth):
        pass
    def getsampwidth(self):
        pass
    def setframerate(self, framerate):
        pass
    def getframerate(self):
        pass
    def setnframes(self, nframes):
        pass
    def getnframes(self):
        pass
    def setcomptype(self, comptype, compname):
        pass
    def getcomptype(self):
        pass
    def getcompname(self):
        pass
    def setparams(self, params):
        pass
    def getparams(self):
        pass
    def setmark(self, id, pos, name):
        pass
    def getmark(self, id):
        pass
    def getmarkers(self):
        pass
    def tell(self):
        pass
    def writeframesraw(self, data):
        pass
    def writeframes(self, data):
        pass
    def close(self):
        pass
    def _ensure_header_written(self, datasize):
        pass
    def _init_compression(self):
        pass
    def _write_header(self, initlength):
        pass
    def _write_form_length(self, datalength):
        pass
    def _patchheader(self):
        pass
    def _writemarkers(self):
        pass
def open(f, mode=None):
   pass
"""# antigravity.py #"""
def geohash(latitude, longitude, datedow):
   pass
"""# argparse.py #"""
class _AttributeHolder(object):
    def __repr__(self):
        pass
    def _get_kwargs(self):
        pass
    def _get_args(self):
        pass
def _copy_items(items):
   pass
class HelpFormatter(object):
    def _indent(self):
        pass
    def _dedent(self):
        pass
    class _Section(object):
        def __init__(self, formatter, parent, heading=None):
                pass
        def format_help(self):
                pass
    def _add_item(self, func, args):
        pass
    def start_section(self, heading):
        pass
    def end_section(self):
        pass
    def add_text(self, text):
        pass
    def add_usage(self, usage, actions, groups, prefix=None):
        pass
    def add_argument(self, action):
        pass
    def add_arguments(self, actions):
        pass
    def format_help(self):
        pass
    def _join_parts(self, part_strings):
        pass
    def _format_usage(self, usage, actions, groups, prefix):
        pass
                def get_lines(parts, indent, prefix=None):
                                pass
    def _format_actions_usage(self, actions, groups):
        pass
    def _format_text(self, text):
        pass
    def _format_action(self, action):
        pass
    def _format_action_invocation(self, action):
        pass
    def _metavar_formatter(self, action, default_metavar):
        pass
        def format(tuple_size):
                pass
    def _format_args(self, action, default_metavar):
        pass
    def _expand_help(self, action):
        pass
    def _iter_indented_subactions(self, action):
        pass
    def _split_lines(self, text, width):
        pass
    def _fill_text(self, text, width, indent):
        pass
    def _get_help_string(self, action):
        pass
    def _get_default_metavar_for_optional(self, action):
        pass
    def _get_default_metavar_for_positional(self, action):
        pass
class RawDescriptionHelpFormatter(HelpFormatter):
    def _fill_text(self, text, width, indent):
        pass
class RawTextHelpFormatter(RawDescriptionHelpFormatter):
    def _split_lines(self, text, width):
        pass
class ArgumentDefaultsHelpFormatter(HelpFormatter):
    def _get_help_string(self, action):
        pass
class MetavarTypeHelpFormatter(HelpFormatter):
    def _get_default_metavar_for_optional(self, action):
        pass
    def _get_default_metavar_for_positional(self, action):
        pass
def _get_action_name(argument):
   pass
class ArgumentError(Exception):
    def __init__(self, argument, message):
        pass
    def __str__(self):
        pass
class ArgumentTypeError(Exception):
class Action(_AttributeHolder):
    def _get_kwargs(self):
        pass
    def format_usage(self):
        pass
    def __call__(self, parser, namespace, values, option_string=None):
        pass
class BooleanOptionalAction(Action):
    def __call__(self, parser, namespace, values, option_string=None):
        pass
    def format_usage(self):
        pass
class _StoreAction(Action):
    def __call__(self, parser, namespace, values, option_string=None):
        pass
class _StoreConstAction(Action):
    def __call__(self, parser, namespace, values, option_string=None):
        pass
class _StoreTrueAction(_StoreConstAction):
class _StoreFalseAction(_StoreConstAction):
class _AppendAction(Action):
    def __call__(self, parser, namespace, values, option_string=None):
        pass
class _AppendConstAction(Action):
    def __call__(self, parser, namespace, values, option_string=None):
        pass
class _CountAction(Action):
    def __call__(self, parser, namespace, values, option_string=None):
        pass
class _HelpAction(Action):
    def __call__(self, parser, namespace, values, option_string=None):
        pass
class _VersionAction(Action):
    def __call__(self, parser, namespace, values, option_string=None):
        pass
class _SubParsersAction(Action):
    class _ChoicesPseudoAction(Action):
        def __init__(self, name, aliases, help):
                pass
    def add_parser(self, name, **kwargs):
        pass
    def _get_subactions(self):
        pass
    def __call__(self, parser, namespace, values, option_string=None):
        pass
class _ExtendAction(_AppendAction):
    def __call__(self, parser, namespace, values, option_string=None):
        pass
class FileType(object):
    def __init__(self, mode='r', bufsize=-1, encoding=None, errors=None):
        pass
    def __call__(self, string):
        pass
    def __repr__(self):
        pass
class Namespace(_AttributeHolder):
    def __init__(self, **kwargs):
        pass
    def __eq__(self, other):
        pass
    def __contains__(self, key):
        pass
class _ActionsContainer(object):
    def register(self, registry_name, value, object):
        pass
    def _registry_get(self, registry_name, value, default=None):
        pass
    def set_defaults(self, **kwargs):
        pass
    def get_default(self, dest):
        pass
    def add_argument(self, *args, **kwargs):
        pass
    def add_argument_group(self, *args, **kwargs):
        pass
    def add_mutually_exclusive_group(self, **kwargs):
        pass
    def _add_action(self, action):
        pass
    def _remove_action(self, action):
        pass
    def _add_container_actions(self, container):
        pass
    def _get_positional_kwargs(self, dest, **kwargs):
        pass
    def _get_optional_kwargs(self, *args, **kwargs):
        pass
    def _pop_action_class(self, kwargs, default=None):
        pass
    def _get_handler(self):
        pass
    def _check_conflict(self, action):
        pass
    def _handle_conflict_error(self, action, conflicting_actions):
        pass
    def _handle_conflict_resolve(self, action, conflicting_actions):
        pass
class _ArgumentGroup(_ActionsContainer):
    def __init__(self, container, title=None, description=None, **kwargs):
        pass
    def _add_action(self, action):
        pass
    def _remove_action(self, action):
        pass
class _MutuallyExclusiveGroup(_ArgumentGroup):
    def __init__(self, container, required=False):
        pass
    def _add_action(self, action):
        pass
    def _remove_action(self, action):
        pass
class ArgumentParser(_AttributeHolder, _ActionsContainer):
        def identity(string):
                pass
    def _get_kwargs(self):
        pass
    def add_subparsers(self, **kwargs):
        pass
    def _add_action(self, action):
        pass
    def _get_optional_actions(self):
        pass
    def _get_positional_actions(self):
        pass
    def parse_args(self, args=None, namespace=None):
        pass
    def parse_known_args(self, args=None, namespace=None):
        pass
    def _parse_known_args(self, arg_strings, namespace):
        pass
        def take_action(action, argument_strings, option_string=None):
                pass
        def consume_optional(start_index):
                pass
        def consume_positionals(start_index):
                pass
    def _read_args_from_files(self, arg_strings):
        pass
    def convert_arg_line_to_args(self, arg_line):
        pass
    def _match_argument(self, action, arg_strings_pattern):
        pass
    def _match_arguments_partial(self, actions, arg_strings_pattern):
        pass
    def _parse_optional(self, arg_string):
        pass
    def _get_option_tuples(self, option_string):
        pass
    def _get_nargs_pattern(self, action):
        pass
    def parse_intermixed_args(self, args=None, namespace=None):
        pass
    def parse_known_intermixed_args(self, args=None, namespace=None):
        pass
    def _get_values(self, action, arg_strings):
        pass
    def _get_value(self, action, arg_string):
        pass
    def _check_value(self, action, value):
        pass
    def format_usage(self):
        pass
    def format_help(self):
        pass
    def _get_formatter(self):
        pass
    def print_usage(self, file=None):
        pass
    def print_help(self, file=None):
        pass
    def _print_message(self, message, file=None):
        pass
    def exit(self, status=0, message=None):
        pass
    def error(self, message):
        pass
"""# ast.py #"""
def literal_eval(node_or_string):
   pass
    def _raise_malformed_node(node):
        pass
    def _convert_num(node):
        pass
    def _convert_signed_num(node):
        pass
    def _convert(node):
        pass
def dump(node, annotate_fields=True, include_attributes=False, *, indent=None):
   pass
    def _format(node, level=0):
        pass
def copy_location(new_node, old_node):
   pass
def fix_missing_locations(node):
   pass
    def _fix(node, lineno, col_offset, end_lineno, end_col_offset):
        pass
def increment_lineno(node, n=1):
   pass
def iter_fields(node):
   pass
def iter_child_nodes(node):
   pass
def get_docstring(node, clean=True):
   pass
def _splitlines_no_ff(source):
   pass
def _pad_whitespace(source):
   pass
def get_source_segment(source, node, *, padded=False):
   pass
def walk(node):
   pass
class NodeVisitor(object):
    def visit(self, node):
        pass
    def generic_visit(self, node):
        pass
    def visit_Constant(self, node):
        pass
class NodeTransformer(NodeVisitor):
       class RewriteName(NodeTransformer):
           def visit_Name(self, node):
                      pass
    def generic_visit(self, node):
        pass
    def _getter(self):
        pass
    def _setter(self, value):
        pass
class _ABC(type):
    def __init__(cls, *args):
        pass
    def __instancecheck__(cls, inst):
        pass
def _new(cls, *args, **kwargs):
   pass
class Num(Constant, metaclass=_ABC):
class Str(Constant, metaclass=_ABC):
class Bytes(Constant, metaclass=_ABC):
class NameConstant(Constant, metaclass=_ABC):
class Ellipsis(Constant, metaclass=_ABC):
    def __new__(cls, *args, **kwargs):
        pass
class slice(AST):
class Index(slice):
    def __new__(cls, value, **kwargs):
        pass
class ExtSlice(slice):
    def __new__(cls, dims=(), **kwargs):
        pass
    def _dims_getter(self):
        pass
    def _dims_setter(self, value):
        pass
class Suite(mod):
class AugLoad(expr_context):
class AugStore(expr_context):
class Param(expr_context):
class _Precedence(IntEnum):
    def next(self):
        pass
class _Unparser(NodeVisitor):
    def __init__(self, *, _avoid_backslashes=False):
        pass
    def interleave(self, inter, f, seq):
        pass
    def items_view(self, traverser, items):
        pass
    def maybe_newline(self):
        pass
    def fill(self, text=""):
        pass
    def write(self, text):
        pass
    def buffer_writer(self, text):
        pass
    def buffer(self):
        pass
    def block(self, *, extra = None):
        pass
    def delimit(self, start, end):
        pass
    def delimit_if(self, start, end, condition):
        pass
    def require_parens(self, precedence, node):
        pass
    def get_precedence(self, node):
        pass
    def set_precedence(self, precedence, *nodes):
        pass
    def get_raw_docstring(self, node):
        pass
    def get_type_comment(self, node):
        pass
    def traverse(self, node):
        pass
    def visit(self, node):
        pass
    def _write_docstring_and_traverse_body(self, node):
        pass
    def visit_Module(self, node):
        pass
    def visit_FunctionType(self, node):
        pass
    def visit_Expr(self, node):
        pass
    def visit_NamedExpr(self, node):
        pass
    def visit_Import(self, node):
        pass
    def visit_ImportFrom(self, node):
        pass
    def visit_Assign(self, node):
        pass
    def visit_AugAssign(self, node):
        pass
    def visit_AnnAssign(self, node):
        pass
    def visit_Return(self, node):
        pass
    def visit_Pass(self, node):
        pass
    def visit_Break(self, node):
        pass
    def visit_Continue(self, node):
        pass
    def visit_Delete(self, node):
        pass
    def visit_Assert(self, node):
        pass
    def visit_Global(self, node):
        pass
    def visit_Nonlocal(self, node):
        pass
    def visit_Await(self, node):
        pass
    def visit_Yield(self, node):
        pass
    def visit_YieldFrom(self, node):
        pass
    def visit_Raise(self, node):
        pass
    def visit_Try(self, node):
        pass
    def visit_ExceptHandler(self, node):
        pass
    def visit_ClassDef(self, node):
        pass
    def visit_FunctionDef(self, node):
        pass
    def visit_AsyncFunctionDef(self, node):
        pass
    def _function_helper(self, node, fill_suffix):
        pass
    def visit_For(self, node):
        pass
    def visit_AsyncFor(self, node):
        pass
    def _for_helper(self, fill, node):
        pass
    def visit_If(self, node):
        pass
    def visit_While(self, node):
        pass
    def visit_With(self, node):
        pass
    def visit_AsyncWith(self, node):
        pass
        def escape_char(c):
                pass
    def _write_str_avoiding_backslashes(self, string, *, quote_types=_ALL_QUOTES):
        pass
    def visit_JoinedStr(self, node):
        pass
    def visit_FormattedValue(self, node):
        pass
    def _fstring_JoinedStr(self, node, write):
        pass
    def _fstring_Constant(self, node, write):
        pass
    def _fstring_FormattedValue(self, node, write):
        pass
    def visit_Name(self, node):
        pass
    def _write_docstring(self, node):
        pass
    def _write_constant(self, value):
        pass
    def visit_Constant(self, node):
        pass
    def visit_List(self, node):
        pass
    def visit_ListComp(self, node):
        pass
    def visit_GeneratorExp(self, node):
        pass
    def visit_SetComp(self, node):
        pass
    def visit_DictComp(self, node):
        pass
    def visit_comprehension(self, node):
        pass
    def visit_IfExp(self, node):
        pass
    def visit_Set(self, node):
        pass
    def visit_Dict(self, node):
        pass
        def write_key_value_pair(k, v):
                pass
        def write_item(item):
                pass
    def visit_Tuple(self, node):
        pass
    def visit_UnaryOp(self, node):
        pass
    def visit_BinOp(self, node):
        pass
    def visit_Compare(self, node):
        pass
    def visit_BoolOp(self, node):
        pass
        def increasing_level_traverse(node):
                pass
    def visit_Attribute(self, node):
        pass
    def visit_Call(self, node):
        pass
    def visit_Subscript(self, node):
        pass
        def is_simple_tuple(slice_value):
                pass
    def visit_Starred(self, node):
        pass
    def visit_Ellipsis(self, node):
        pass
    def visit_Slice(self, node):
        pass
    def visit_arg(self, node):
        pass
    def visit_arguments(self, node):
        pass
    def visit_keyword(self, node):
        pass
    def visit_Lambda(self, node):
        pass
    def visit_alias(self, node):
        pass
    def visit_withitem(self, node):
        pass
def unparse(ast_obj):
   pass
def main():
   pass
"""# asynchat.py #"""
class async_chat(asyncore.dispatcher):
    def __init__(self, sock=None, map=None):
        pass
    def collect_incoming_data(self, data):
        pass
    def _collect_incoming_data(self, data):
        pass
    def _get_data(self):
        pass
    def found_terminator(self):
        pass
    def set_terminator(self, term):
        pass
    def get_terminator(self):
        pass
    def handle_read(self):
        pass
    def handle_write(self):
        pass
    def handle_close(self):
        pass
    def push(self, data):
        pass
    def push_with_producer(self, producer):
        pass
    def readable(self):
        pass
    def writable(self):
        pass
    def close_when_done(self):
        pass
    def initiate_send(self):
        pass
    def discard_buffers(self):
        pass
class simple_producer:
    def __init__(self, data, buffer_size=512):
        pass
    def more(self):
        pass
def find_prefix_at_end(haystack, needle):
   pass
"""# asyncore.py #"""
def _strerror(err):
   pass
class ExitNow(Exception):
def read(obj):
   pass
def write(obj):
   pass
def _exception(obj):
   pass
def readwrite(obj, flags):
   pass
def poll(timeout=0.0, map=None):
   pass
def loop(timeout=30.0, use_poll=False, map=None, count=None):
   pass
class dispatcher:
    def __init__(self, sock=None, map=None):
        pass
    def __repr__(self):
        pass
    def add_channel(self, map=None):
        pass
    def del_channel(self, map=None):
        pass
    def create_socket(self, family=socket.AF_INET, type=socket.SOCK_STREAM):
        pass
    def set_socket(self, sock, map=None):
        pass
    def set_reuse_addr(self):
        pass
    def readable(self):
        pass
    def writable(self):
        pass
    def listen(self, num):
        pass
    def bind(self, addr):
        pass
    def connect(self, address):
        pass
    def accept(self):
        pass
    def send(self, data):
        pass
    def recv(self, buffer_size):
        pass
    def close(self):
        pass
    def log(self, message):
        pass
    def log_info(self, message, type='info'):
        pass
    def handle_read_event(self):
        pass
    def handle_connect_event(self):
        pass
    def handle_write_event(self):
        pass
    def handle_expt_event(self):
        pass
    def handle_error(self):
        pass
    def handle_expt(self):
        pass
    def handle_read(self):
        pass
    def handle_write(self):
        pass
    def handle_connect(self):
        pass
    def handle_accept(self):
        pass
    def handle_accepted(self, sock, addr):
        pass
    def handle_close(self):
        pass
class dispatcher_with_send(dispatcher):
    def __init__(self, sock=None, map=None):
        pass
    def initiate_send(self):
        pass
    def handle_write(self):
        pass
    def writable(self):
        pass
    def send(self, data):
        pass
def compact_traceback():
   pass
def close_all(map=None, ignore_all=False):
   pass
    class file_wrapper:
        def __init__(self, fd):
                pass
        def __del__(self):
                pass
        def recv(self, *args):
                pass
        def send(self, *args):
                pass
        def getsockopt(self, level, optname, buflen=None):
                pass
        def close(self):
                pass
        def fileno(self):
                pass
    class file_dispatcher(dispatcher):
        def __init__(self, fd, map=None):
                pass
        def set_file(self, fd):
                pass
"""# base64.py #"""
def _bytes_from_decode_data(s):
   pass
def encode(input, output):
   pass
def decode(input, output):
   pass
def _input_type_check(s):
   pass
def encodebytes(s):
   pass
def decodebytes(s):
   pass
def main():
   pass
def test():
   pass
"""# bdb.py #"""
class BdbQuit(Exception):
class Bdb:
    def __init__(self, skip=None):
        pass
    def canonic(self, filename):
        pass
    def reset(self):
        pass
    def trace_dispatch(self, frame, event, arg):
        pass
    def dispatch_line(self, frame):
        pass
    def dispatch_call(self, frame, arg):
        pass
    def dispatch_return(self, frame, arg):
        pass
    def dispatch_exception(self, frame, arg):
        pass
    def is_skipped_module(self, module_name):
        pass
    def stop_here(self, frame):
        pass
    def break_here(self, frame):
        pass
    def do_clear(self, arg):
        pass
    def break_anywhere(self, frame):
        pass
    def user_call(self, frame, argument_list):
        pass
    def user_line(self, frame):
        pass
    def user_return(self, frame, return_value):
        pass
    def user_exception(self, frame, exc_info):
        pass
    def _set_stopinfo(self, stopframe, returnframe, stoplineno=0):
        pass
    def set_until(self, frame, lineno=None):
        pass
    def set_step(self):
        pass
    def set_next(self, frame):
        pass
    def set_return(self, frame):
        pass
    def set_trace(self, frame=None):
        pass
    def set_continue(self):
        pass
    def set_quit(self):
        pass
    def _prune_breaks(self, filename, lineno):
        pass
    def clear_break(self, filename, lineno):
        pass
    def clear_bpbynumber(self, arg):
        pass
    def clear_all_file_breaks(self, filename):
        pass
    def clear_all_breaks(self):
        pass
    def get_bpbynumber(self, arg):
        pass
    def get_break(self, filename, lineno):
        pass
    def get_breaks(self, filename, lineno):
        pass
    def get_file_breaks(self, filename):
        pass
    def get_all_breaks(self):
        pass
    def get_stack(self, f, t):
        pass
    def format_stack_entry(self, frame_lineno, lprefix=': '):
        pass
    def run(self, cmd, globals=None, locals=None):
        pass
    def runeval(self, expr, globals=None, locals=None):
        pass
    def runctx(self, cmd, globals, locals):
        pass
    def runcall(self, func, /, *args, **kwds):
        pass
def set_trace():
   pass
class Breakpoint:
    def __init__(self, file, line, temporary=False, cond=None, funcname=None):
        pass
    def deleteMe(self):
        pass
    def enable(self):
        pass
    def disable(self):
        pass
    def bpprint(self, out=None):
        pass
    def bpformat(self):
        pass
    def __str__(self):
        pass
def checkfuncname(b, frame):
   pass
def effective(file, line, frame):
   pass
class Tdb(Bdb):
    def user_call(self, frame, args):
        pass
    def user_line(self, frame):
        pass
    def user_return(self, frame, retval):
        pass
    def user_exception(self, frame, exc_stuff):
        pass
def foo(n):
   pass
def bar(a):
   pass
def test():
   pass
"""# binhex.py #"""
class Error(Exception):
class FInfo:
    def __init__(self):
        pass
def getfileinfo(name):
   pass
class openrsrc:
    def __init__(self, *args):
        pass
    def read(self, *args):
        pass
    def write(self, *args):
        pass
    def close(self):
        pass
def _ignore_deprecation_warning():
   pass
class _Hqxcoderengine:
    def __init__(self, ofp):
        pass
    def write(self, data):
        pass
    def _flush(self, force):
        pass
    def close(self):
        pass
class _Rlecoderengine:
    def __init__(self, ofp):
        pass
    def write(self, data):
        pass
    def close(self):
        pass
class BinHex:
    def __init__(self, name_finfo_dlen_rlen, ofp):
        pass
    def _writeinfo(self, name, finfo):
        pass
    def _write(self, data):
        pass
    def _writecrc(self):
        pass
    def write(self, data):
        pass
    def close_data(self):
        pass
    def write_rsrc(self, data):
        pass
    def close(self):
        pass
def binhex(inp, out):
   pass
class _Hqxdecoderengine:
    def __init__(self, ifp):
        pass
    def read(self, totalwtd):
        pass
    def close(self):
        pass
class _Rledecoderengine:
    def __init__(self, ifp):
        pass
    def read(self, wtd):
        pass
    def _fill(self, wtd):
        pass
    def close(self):
        pass
class HexBin:
    def __init__(self, ifp):
        pass
    def _read(self, len):
        pass
    def _checkcrc(self):
        pass
    def _readheader(self):
        pass
    def read(self, *n):
        pass
    def close_data(self):
        pass
    def read_rsrc(self, *n):
        pass
    def close(self):
        pass
def hexbin(inp, out):
   pass
"""# bisect.py #"""
def insort_right(a, x, lo=0, hi=None):
   pass
def bisect_right(a, x, lo=0, hi=None):
   pass
def insort_left(a, x, lo=0, hi=None):
   pass
def bisect_left(a, x, lo=0, hi=None):
   pass
"""# bz2.py #"""
    def __init__(self, filename, mode="r", *, compresslevel=9):
        pass
    def close(self):
        pass
    def closed(self):
        pass
    def fileno(self):
        pass
    def seekable(self):
        pass
    def readable(self):
        pass
    def writable(self):
        pass
    def peek(self, n=0):
        pass
    def read(self, size=-1):
        pass
    def readinto(self, b):
        pass
    def readline(self, size=-1):
        pass
    def readlines(self, size=-1):
        pass
    def write(self, data):
        pass
    def writelines(self, seq):
        pass
    def seek(self, offset, whence=io.SEEK_SET):
        pass
    def tell(self):
        pass
def compress(data, compresslevel=9):
   pass
def decompress(data):
   pass
"""# calendar.py #"""
class IllegalMonthError(ValueError):
    def __init__(self, month):
        pass
    def __str__(self):
        pass
class IllegalWeekdayError(ValueError):
    def __init__(self, weekday):
        pass
    def __str__(self):
        pass
class _localized_month:
    def __init__(self, format):
        pass
    def __getitem__(self, i):
        pass
    def __len__(self):
        pass
class _localized_day:
    def __init__(self, format):
        pass
    def __getitem__(self, i):
        pass
    def __len__(self):
        pass
def isleap(year):
   pass
def leapdays(y1, y2):
   pass
def weekday(year, month, day):
   pass
def monthrange(year, month):
   pass
def _monthlen(year, month):
   pass
def _prevmonth(year, month):
   pass
def _nextmonth(year, month):
   pass
class Calendar(object):
    def __init__(self, firstweekday=0):
        pass
    def getfirstweekday(self):
        pass
    def setfirstweekday(self, firstweekday):
        pass
    def iterweekdays(self):
        pass
    def itermonthdates(self, year, month):
        pass
    def itermonthdays(self, year, month):
        pass
    def monthdatescalendar(self, year, month):
        pass
    def monthdayscalendar(self, year, month):
        pass
    def yeardatescalendar(self, year, width=3):
        pass
    def yeardayscalendar(self, year, width=3):
        pass
class TextCalendar(Calendar):
    def prweek(self, theweek, width):
        pass
    def formatday(self, day, weekday, width):
        pass
    def formatweek(self, theweek, width):
        pass
    def formatweekday(self, day, width):
        pass
    def formatweekheader(self, width):
        pass
    def formatmonthname(self, theyear, themonth, width, withyear=True):
        pass
    def prmonth(self, theyear, themonth, w=0, l=0):
        pass
    def formatmonth(self, theyear, themonth, w=0, l=0):
        pass
    def formatyear(self, theyear, w=2, l=1, c=6, m=3):
        pass
    def pryear(self, theyear, w=0, l=0, c=6, m=3):
        pass
class HTMLCalendar(Calendar):
    def formatday(self, day, weekday):
        pass
    def formatweek(self, theweek):
        pass
    def formatweekday(self, day):
        pass
    def formatweekheader(self):
        pass
    def formatmonthname(self, theyear, themonth, withyear=True):
        pass
    def formatmonth(self, theyear, themonth, withyear=True):
        pass
    def formatyear(self, theyear, width=3):
        pass
    def formatyearpage(self, theyear, width=3, css='calendar.css', encoding=None):
        pass
class different_locale:
    def __init__(self, locale):
        pass
    def __enter__(self):
        pass
    def __exit__(self, *args):
        pass
class LocaleTextCalendar(TextCalendar):
    def __init__(self, firstweekday=0, locale=None):
        pass
    def formatweekday(self, day, width):
        pass
    def formatmonthname(self, theyear, themonth, width, withyear=True):
        pass
class LocaleHTMLCalendar(HTMLCalendar):
    def __init__(self, firstweekday=0, locale=None):
        pass
    def formatweekday(self, day):
        pass
    def formatmonthname(self, theyear, themonth, withyear=True):
        pass
def setfirstweekday(firstweekday):
   pass
def format(cols, colwidth=_colwidth, spacing=_spacing):
   pass
def formatstring(cols, colwidth=_colwidth, spacing=_spacing):
   pass
def timegm(tuple):
   pass
def main(args):
   pass
"""# cgi.py #"""
def initlog(*allargs):
   pass
def dolog(fmt, *args):
   pass
def nolog(*allargs):
   pass
def closelog():
   pass
def parse(fp=None, environ=os.environ, keep_blank_values=0, strict_parsing=0):
   pass
def parse_multipart(fp, pdict, encoding="utf-8", errors="replace"):
   pass
def _parseparam(s):
   pass
def parse_header(line):
   pass
class MiniFieldStorage:
    def __init__(self, name, value):
        pass
    def __repr__(self):
        pass
class FieldStorage:
    def __del__(self):
        pass
    def __enter__(self):
        pass
    def __exit__(self, *args):
        pass
    def __repr__(self):
        pass
    def __iter__(self):
        pass
    def __getattr__(self, name):
        pass
    def __getitem__(self, key):
        pass
    def getvalue(self, key, default=None):
        pass
    def getfirst(self, key, default=None):
        pass
    def getlist(self, key):
        pass
    def keys(self):
        pass
    def __contains__(self, key):
        pass
    def __len__(self):
        pass
    def __bool__(self):
        pass
    def read_urlencoded(self):
        pass
    def read_multi(self, environ, keep_blank_values, strict_parsing):
        pass
    def read_single(self):
        pass
    def read_binary(self):
        pass
    def read_lines(self):
        pass
    def __write(self, line):
        pass
    def read_lines_to_eof(self):
        pass
    def read_lines_to_outerboundary(self):
        pass
    def skip_lines(self):
        pass
    def make_file(self):
        pass
def test(environ=os.environ):
   pass
        def f():
                pass
        def g(f=f):
                pass
def print_exception(type=None, value=None, tb=None, limit=None):
   pass
def print_environ(environ=os.environ):
   pass
def print_form(form):
   pass
def print_directory():
   pass
def print_arguments():
   pass
def print_environ_usage():
   pass
def valid_boundary(s):
   pass
"""# cgitb.py #"""
def reset():
   pass
def small(text):
   pass
def strong(text):
   pass
def grey(text):
   pass
def lookup(name, frame, locals):
   pass
def scanvars(reader, frame, locals):
   pass
def html(einfo, context=5):
   pass
        def reader(lnum=[lnum]):
                pass
def text(einfo, context=5):
   pass
        def reader(lnum=[lnum]):
                pass
class Hook:
    def __call__(self, etype, evalue, etb):
        pass
    def handle(self, info=None):
        pass
def enable(display=1, logdir=None, context=5, format="html"):
   pass
"""# chunk.py #"""
class Chunk:
    def __init__(self, file, align=True, bigendian=True, inclheader=False):
        pass
    def getname(self):
        pass
    def getsize(self):
        pass
    def close(self):
        pass
    def isatty(self):
        pass
    def seek(self, pos, whence=0):
        pass
    def tell(self):
        pass
    def read(self, size=-1):
        pass
    def skip(self):
        pass
"""# cmd.py #"""
class Cmd:
    def __init__(self, completekey='tab', stdin=None, stdout=None):
        pass
    def cmdloop(self, intro=None):
        pass
    def precmd(self, line):
        pass
    def postcmd(self, stop, line):
        pass
    def preloop(self):
        pass
    def postloop(self):
        pass
    def parseline(self, line):
        pass
    def onecmd(self, line):
        pass
    def emptyline(self):
        pass
    def default(self, line):
        pass
    def completedefault(self, *ignored):
        pass
    def completenames(self, text, *ignored):
        pass
    def complete(self, text, state):
        pass
    def get_names(self):
        pass
    def complete_help(self, *args):
        pass
    def do_help(self, arg):
        pass
    def print_topics(self, header, cmds, cmdlen, maxcol):
        pass
    def columnize(self, list, displaywidth=80):
        pass
"""# code.py #"""
class InteractiveInterpreter:
    def __init__(self, locals=None):
        pass
    def runsource(self, source, filename="<input>", symbol="single"):
        pass
    def runcode(self, code):
        pass
    def showsyntaxerror(self, filename=None):
        pass
    def showtraceback(self):
        pass
    def write(self, data):
        pass
class InteractiveConsole(InteractiveInterpreter):
    def __init__(self, locals=None, filename="<console>"):
        pass
    def resetbuffer(self):
        pass
    def interact(self, banner=None, exitmsg=None):
        pass
    def push(self, line):
        pass
    def raw_input(self, prompt=""):
        pass
def interact(banner=None, readfunc=None, local=None, exitmsg=None):
   pass
"""# codecs.py #"""
class CodecInfo(tuple):
    def __repr__(self):
        pass
class Codec:
    def encode(self, input, errors='strict'):
        pass
    def decode(self, input, errors='strict'):
        pass
class IncrementalEncoder(object):
    def __init__(self, errors='strict'):
        pass
    def encode(self, input, final=False):
        pass
    def reset(self):
        pass
    def getstate(self):
        pass
    def setstate(self, state):
        pass
class BufferedIncrementalEncoder(IncrementalEncoder):
    def __init__(self, errors='strict'):
        pass
    def _buffer_encode(self, input, errors, final):
        pass
    def encode(self, input, final=False):
        pass
    def reset(self):
        pass
    def getstate(self):
        pass
    def setstate(self, state):
        pass
class IncrementalDecoder(object):
    def __init__(self, errors='strict'):
        pass
    def decode(self, input, final=False):
        pass
    def reset(self):
        pass
    def getstate(self):
        pass
    def setstate(self, state):
        pass
class BufferedIncrementalDecoder(IncrementalDecoder):
    def __init__(self, errors='strict'):
        pass
    def _buffer_decode(self, input, errors, final):
        pass
    def decode(self, input, final=False):
        pass
    def reset(self):
        pass
    def getstate(self):
        pass
    def setstate(self, state):
        pass
class StreamWriter(Codec):
    def __init__(self, stream, errors='strict'):
        pass
    def write(self, object):
        pass
    def writelines(self, list):
        pass
    def reset(self):
        pass
    def seek(self, offset, whence=0):
        pass
    def __enter__(self):
        pass
    def __exit__(self, type, value, tb):
        pass
class StreamReader(Codec):
    def __init__(self, stream, errors='strict'):
        pass
    def decode(self, input, errors='strict'):
        pass
    def read(self, size=-1, chars=-1, firstline=False):
        pass
    def readline(self, size=None, keepends=True):
        pass
    def readlines(self, sizehint=None, keepends=True):
        pass
    def reset(self):
        pass
    def seek(self, offset, whence=0):
        pass
    def __next__(self):
        pass
    def __iter__(self):
        pass
    def __enter__(self):
        pass
    def __exit__(self, type, value, tb):
        pass
class StreamReaderWriter:
    def __init__(self, stream, Reader, Writer, errors='strict'):
        pass
    def read(self, size=-1):
        pass
    def readline(self, size=None):
        pass
    def readlines(self, sizehint=None):
        pass
    def __next__(self):
        pass
    def __iter__(self):
        pass
    def write(self, data):
        pass
    def writelines(self, list):
        pass
    def reset(self):
        pass
    def seek(self, offset, whence=0):
        pass
    def __enter__(self):
        pass
    def __exit__(self, type, value, tb):
        pass
class StreamRecoder:
    def read(self, size=-1):
        pass
    def readline(self, size=None):
        pass
    def readlines(self, sizehint=None):
        pass
    def __next__(self):
        pass
    def __iter__(self):
        pass
    def write(self, data):
        pass
    def writelines(self, list):
        pass
    def reset(self):
        pass
    def seek(self, offset, whence=0):
        pass
    def __enter__(self):
        pass
    def __exit__(self, type, value, tb):
        pass
def open(filename, mode='r', encoding=None, errors='strict', buffering=-1):
   pass
def EncodedFile(file, data_encoding, file_encoding=None, errors='strict'):
   pass
def getencoder(encoding):
   pass
def getdecoder(encoding):
   pass
def getincrementalencoder(encoding):
   pass
def getincrementaldecoder(encoding):
   pass
def getreader(encoding):
   pass
def getwriter(encoding):
   pass
def iterencode(iterator, encoding, errors='strict', **kwargs):
   pass
def iterdecode(iterator, encoding, errors='strict', **kwargs):
   pass
def make_identity_dict(rng):
   pass
def make_encoding_map(decoding_map):
   pass
"""# codeop.py #"""
def _maybe_compile(compiler, source, filename, symbol):
   pass
def _compile(source, filename, symbol):
   pass
def compile_command(source, filename="<input>", symbol="single"):
   pass
class Compile:
    def __init__(self):
        pass
    def __call__(self, source, filename, symbol):
        pass
class CommandCompiler:
    def __init__(self,):
        pass
    def __call__(self, source, filename="<input>", symbol="single"):
        pass
"""# collections #"""
def __getattr__(name):
   pass
class _OrderedDictKeysView(_collections_abc.KeysView):
    def __reversed__(self):
        pass
class _OrderedDictItemsView(_collections_abc.ItemsView):
    def __reversed__(self):
        pass
class _OrderedDictValuesView(_collections_abc.ValuesView):
    def __reversed__(self):
        pass
class _Link(object):
class OrderedDict(dict):
    def __init__(self, other=(), /, **kwds):
        pass
    def __delitem__(self, key, dict_delitem=dict.__delitem__):
        pass
    def __iter__(self):
        pass
    def __reversed__(self):
        pass
    def clear(self):
        pass
    def popitem(self, last=True):
        pass
    def move_to_end(self, key, last=True):
        pass
    def __sizeof__(self):
        pass
    def keys(self):
        pass
    def items(self):
        pass
    def values(self):
        pass
    def pop(self, key, default=__marker):
        pass
    def setdefault(self, key, default=None):
        pass
    def __repr__(self):
        pass
    def __reduce__(self):
        pass
    def copy(self):
        pass
    def fromkeys(cls, iterable, value=None):
        pass
    def __eq__(self, other):
        pass
    def __ior__(self, other):
        pass
    def __or__(self, other):
        pass
    def __ror__(self, other):
        pass
def namedtuple(typename, field_names, *, rename=False, defaults=None, module=None):
   pass
    def _make(cls, iterable):
        pass
    def _replace(self, /, **kwds):
        pass
    def __repr__(self):
        pass
    def _asdict(self):
        pass
    def __getnewargs__(self):
        pass
def _count_elements(mapping, iterable):
   pass
class Counter(dict):
    def __init__(self, iterable=None, /, **kwds):
        pass
    def __missing__(self, key):
        pass
    def most_common(self, n=None):
        pass
    def elements(self):
        pass
    def fromkeys(cls, iterable, v=None):
        pass
    def update(self, iterable=None, /, **kwds):
        pass
    def subtract(self, iterable=None, /, **kwds):
        pass
    def copy(self):
        pass
    def __reduce__(self):
        pass
    def __delitem__(self, elem):
        pass
    def __repr__(self):
        pass
    def __add__(self, other):
        pass
    def __sub__(self, other):
        pass
    def __or__(self, other):
        pass
    def __and__(self, other):
        pass
    def __pos__(self):
        pass
    def __neg__(self):
        pass
    def _keep_positive(self):
        pass
    def __iadd__(self, other):
        pass
    def __isub__(self, other):
        pass
    def __ior__(self, other):
        pass
    def __iand__(self, other):
        pass
class ChainMap(_collections_abc.MutableMapping):
    def __init__(self, *maps):
        pass
    def __missing__(self, key):
        pass
    def __getitem__(self, key):
        pass
    def get(self, key, default=None):
        pass
    def __len__(self):
        pass
    def __iter__(self):
        pass
    def __contains__(self, key):
        pass
    def __bool__(self):
        pass
    def __repr__(self):
        pass
    def fromkeys(cls, iterable, *args):
        pass
    def copy(self):
        pass
    def new_child(self, m=None):                # like Django's Context.push()
        pass
    def parents(self):                          # like Django's Context.pop()
        pass
    def __setitem__(self, key, value):
        pass
    def __delitem__(self, key):
        pass
    def popitem(self):
        pass
    def pop(self, key, *args):
        pass
    def clear(self):
        pass
    def __ior__(self, other):
        pass
    def __or__(self, other):
        pass
    def __ror__(self, other):
        pass
class UserDict(_collections_abc.MutableMapping):
    def __init__(self, dict=None, /, **kwargs):
        pass
    def __len__(self):
        pass
    def __getitem__(self, key):
        pass
    def __setitem__(self, key, item):
        pass
    def __delitem__(self, key):
        pass
    def __iter__(self):
        pass
    def __contains__(self, key):
        pass
    def __repr__(self):
        pass
    def __or__(self, other):
        pass
    def __ror__(self, other):
        pass
    def __ior__(self, other):
        pass
    def __copy__(self):
        pass
    def copy(self):
        pass
    def fromkeys(cls, iterable, value=None):
        pass
class UserList(_collections_abc.MutableSequence):
    def __init__(self, initlist=None):
        pass
    def __repr__(self):
        pass
    def __lt__(self, other):
        pass
    def __le__(self, other):
        pass
    def __eq__(self, other):
        pass
    def __gt__(self, other):
        pass
    def __ge__(self, other):
        pass
    def __cast(self, other):
        pass
    def __contains__(self, item):
        pass
    def __len__(self):
        pass
    def __getitem__(self, i):
        pass
    def __setitem__(self, i, item):
        pass
    def __delitem__(self, i):
        pass
    def __add__(self, other):
        pass
    def __radd__(self, other):
        pass
    def __iadd__(self, other):
        pass
    def __mul__(self, n):
        pass
    def __imul__(self, n):
        pass
    def __copy__(self):
        pass
    def append(self, item):
        pass
    def insert(self, i, item):
        pass
    def pop(self, i=-1):
        pass
    def remove(self, item):
        pass
    def clear(self):
        pass
    def copy(self):
        pass
    def count(self, item):
        pass
    def index(self, item, *args):
        pass
    def reverse(self):
        pass
    def sort(self, /, *args, **kwds):
        pass
    def extend(self, other):
        pass
class UserString(_collections_abc.Sequence):
    def __init__(self, seq):
        pass
    def __str__(self):
        pass
    def __repr__(self):
        pass
    def __int__(self):
        pass
    def __float__(self):
        pass
    def __complex__(self):
        pass
    def __hash__(self):
        pass
    def __getnewargs__(self):
        pass
    def __eq__(self, string):
        pass
    def __lt__(self, string):
        pass
    def __le__(self, string):
        pass
    def __gt__(self, string):
        pass
    def __ge__(self, string):
        pass
    def __contains__(self, char):
        pass
    def __len__(self):
        pass
    def __getitem__(self, index):
        pass
    def __add__(self, other):
        pass
    def __radd__(self, other):
        pass
    def __mul__(self, n):
        pass
    def __mod__(self, args):
        pass
    def __rmod__(self, template):
        pass
    def capitalize(self):
        pass
    def casefold(self):
        pass
    def center(self, width, *args):
        pass
    def count(self, sub, start=0, end=_sys.maxsize):
        pass
    def removeprefix(self, prefix, /):
        pass
    def removesuffix(self, suffix, /):
        pass
    def encode(self, encoding='utf-8', errors='strict'):
        pass
    def endswith(self, suffix, start=0, end=_sys.maxsize):
        pass
    def expandtabs(self, tabsize=8):
        pass
    def find(self, sub, start=0, end=_sys.maxsize):
        pass
    def format(self, /, *args, **kwds):
        pass
    def format_map(self, mapping):
        pass
    def index(self, sub, start=0, end=_sys.maxsize):
        pass
    def isalpha(self):
        pass
    def isalnum(self):
        pass
    def isascii(self):
        pass
    def isdecimal(self):
        pass
    def isdigit(self):
        pass
    def isidentifier(self):
        pass
    def islower(self):
        pass
    def isnumeric(self):
        pass
    def isprintable(self):
        pass
    def isspace(self):
        pass
    def istitle(self):
        pass
    def isupper(self):
        pass
    def join(self, seq):
        pass
    def ljust(self, width, *args):
        pass
    def lower(self):
        pass
    def lstrip(self, chars=None):
        pass
    def partition(self, sep):
        pass
    def replace(self, old, new, maxsplit=-1):
        pass
    def rfind(self, sub, start=0, end=_sys.maxsize):
        pass
    def rindex(self, sub, start=0, end=_sys.maxsize):
        pass
    def rjust(self, width, *args):
        pass
    def rpartition(self, sep):
        pass
    def rstrip(self, chars=None):
        pass
    def split(self, sep=None, maxsplit=-1):
        pass
    def rsplit(self, sep=None, maxsplit=-1):
        pass
    def splitlines(self, keepends=False):
        pass
    def startswith(self, prefix, start=0, end=_sys.maxsize):
        pass
    def strip(self, chars=None):
        pass
    def swapcase(self):
        pass
    def title(self):
        pass
    def translate(self, *args):
        pass
    def upper(self):
        pass
    def zfill(self, width):
        pass
"""# colorsys.py #"""
def rgb_to_yiq(r, g, b):
   pass
def yiq_to_rgb(y, i, q):
   pass
def rgb_to_hls(r, g, b):
   pass
def hls_to_rgb(h, l, s):
   pass
def _v(m1, m2, hue):
   pass
def rgb_to_hsv(r, g, b):
   pass
def hsv_to_rgb(h, s, v):
   pass
"""# compileall.py #"""
def _walk_dir(dir, maxlevels, quiet=0):
   pass
def main():
   pass
"""# configparser.py #"""
class Error(Exception):
    def __init__(self, msg=''):
        pass
    def __repr__(self):
        pass
class NoSectionError(Error):
    def __init__(self, section):
        pass
class DuplicateSectionError(Error):
    def __init__(self, section, source=None, lineno=None):
        pass
class DuplicateOptionError(Error):
    def __init__(self, section, option, source=None, lineno=None):
        pass
class NoOptionError(Error):
    def __init__(self, option, section):
        pass
class InterpolationError(Error):
    def __init__(self, option, section, msg):
        pass
class InterpolationMissingOptionError(InterpolationError):
    def __init__(self, option, section, rawval, reference):
        pass
class InterpolationSyntaxError(InterpolationError):
class InterpolationDepthError(InterpolationError):
    def __init__(self, option, section, rawval):
        pass
class ParsingError(Error):
    def __init__(self, source=None, filename=None):
        pass
    def filename(self):
        pass
    def filename(self, value):
        pass
    def append(self, lineno, line):
        pass
class MissingSectionHeaderError(ParsingError):
    def __init__(self, filename, lineno, line):
        pass
class Interpolation:
    def before_get(self, parser, section, option, value, defaults):
        pass
    def before_set(self, parser, section, option, value):
        pass
    def before_read(self, parser, section, option, value):
        pass
    def before_write(self, parser, section, option, value):
        pass
class BasicInterpolation(Interpolation):
    def before_get(self, parser, section, option, value, defaults):
        pass
    def before_set(self, parser, section, option, value):
        pass
class ExtendedInterpolation(Interpolation):
    def before_get(self, parser, section, option, value, defaults):
        pass
    def before_set(self, parser, section, option, value):
        pass
class LegacyInterpolation(Interpolation):
    def before_get(self, parser, section, option, value, vars):
        pass
    def before_set(self, parser, section, option, value):
        pass
    def _interpolation_replace(match, parser):
        pass
class RawConfigParser(MutableMapping):
    def defaults(self):
        pass
    def sections(self):
        pass
    def add_section(self, section):
        pass
    def has_section(self, section):
        pass
    def options(self, section):
        pass
    def read(self, filenames, encoding=None):
        pass
    def read_file(self, f, source=None):
        pass
    def read_string(self, string, source='<string>'):
        pass
    def read_dict(self, dictionary, source='<dict>'):
        pass
    def readfp(self, fp, filename=None):
        pass
    def get(self, section, option, *, raw=False, vars=None, fallback=_UNSET):
        pass
    def _get(self, section, conv, option, **kwargs):
        pass
    def items(self, section=_UNSET, raw=False, vars=None):
        pass
    def popitem(self):
        pass
    def optionxform(self, optionstr):
        pass
    def has_option(self, section, option):
        pass
    def set(self, section, option, value=None):
        pass
    def write(self, fp, space_around_delimiters=True):
        pass
    def _write_section(self, fp, section_name, section_items, delimiter):
        pass
    def remove_option(self, section, option):
        pass
    def remove_section(self, section):
        pass
    def __getitem__(self, key):
        pass
    def __setitem__(self, key, value):
        pass
    def __delitem__(self, key):
        pass
    def __contains__(self, key):
        pass
    def __len__(self):
        pass
    def __iter__(self):
        pass
    def _read(self, fp, fpname):
        pass
    def _join_multiline_values(self):
        pass
    def _read_defaults(self, defaults):
        pass
    def _handle_error(self, exc, fpname, lineno, line):
        pass
    def _unify_values(self, section, vars):
        pass
    def _convert_to_boolean(self, value):
        pass
    def _validate_value_types(self, *, section="", option="", value=""):
        pass
    def converters(self):
        pass
class ConfigParser(RawConfigParser):
    def set(self, section, option, value=None):
        pass
    def add_section(self, section):
        pass
    def _read_defaults(self, defaults):
        pass
class SafeConfigParser(ConfigParser):
    def __init__(self, *args, **kwargs):
        pass
class SectionProxy(MutableMapping):
    def __init__(self, parser, name):
        pass
    def __repr__(self):
        pass
    def __getitem__(self, key):
        pass
    def __setitem__(self, key, value):
        pass
    def __delitem__(self, key):
        pass
    def __contains__(self, key):
        pass
    def __len__(self):
        pass
    def __iter__(self):
        pass
    def _options(self):
        pass
    def parser(self):
        pass
    def name(self):
        pass
class ConverterMapping(MutableMapping):
    def __init__(self, parser):
        pass
    def __getitem__(self, key):
        pass
    def __setitem__(self, key, value):
        pass
    def __delitem__(self, key):
        pass
    def __iter__(self):
        pass
    def __len__(self):
        pass
"""# contextlib.py #"""
class AbstractContextManager(abc.ABC):
    def __enter__(self):
        pass
    def __exit__(self, exc_type, exc_value, traceback):
        pass
    def __subclasshook__(cls, C):
        pass
class AbstractAsyncContextManager(abc.ABC):
    def __subclasshook__(cls, C):
        pass
class ContextDecorator(object):
    def _recreate_cm(self):
        pass
    def __call__(self, func):
        pass
        def inner(*args, **kwds):
                pass
class _GeneratorContextManagerBase:
    def __init__(self, func, args, kwds):
        pass
    def _recreate_cm(self):
        pass
    def __enter__(self):
        pass
    def __exit__(self, type, value, traceback):
        pass
def contextmanager(func):
   pass
        def some_generator(<arguments>):
                pass
    def helper(*args, **kwds):
        pass
def asynccontextmanager(func):
   pass
    def helper(*args, **kwds):
        pass
class closing(AbstractContextManager):
    def __init__(self, thing):
        pass
    def __enter__(self):
        pass
    def __exit__(self, *exc_info):
        pass
class _RedirectStream(AbstractContextManager):
    def __init__(self, new_target):
        pass
    def __enter__(self):
        pass
    def __exit__(self, exctype, excinst, exctb):
        pass
class redirect_stdout(_RedirectStream):
class redirect_stderr(_RedirectStream):
class suppress(AbstractContextManager):
    def __init__(self, *exceptions):
        pass
    def __enter__(self):
        pass
    def __exit__(self, exctype, excinst, exctb):
        pass
class _BaseExitStack:
    def _create_exit_wrapper(cm, cm_exit):
        pass
    def _create_cb_wrapper(callback, /, *args, **kwds):
        pass
        def _exit_wrapper(exc_type, exc, tb):
                pass
    def __init__(self):
        pass
    def pop_all(self):
        pass
    def push(self, exit):
        pass
    def enter_context(self, cm):
        pass
    def callback(self, callback, /, *args, **kwds):
        pass
    def _push_cm_exit(self, cm, cm_exit):
        pass
    def _push_exit_callback(self, callback, is_sync=True):
        pass
class ExitStack(_BaseExitStack, AbstractContextManager):
    def __enter__(self):
        pass
    def __exit__(self, *exc_details):
        pass
        def _fix_exception_context(new_exc, old_exc):
                pass
    def close(self):
        pass
class AsyncExitStack(_BaseExitStack, AbstractAsyncContextManager):
    def _create_async_exit_wrapper(cm, cm_exit):
        pass
    def _create_async_cb_wrapper(callback, /, *args, **kwds):
        pass
    def push_async_exit(self, exit):
        pass
    def push_async_callback(self, callback, /, *args, **kwds):
        pass
    def _push_async_cm_exit(self, cm, cm_exit):
        pass
        def _fix_exception_context(new_exc, old_exc):
                pass
class nullcontext(AbstractContextManager):
    def __init__(self, enter_result=None):
        pass
    def __enter__(self):
        pass
    def __exit__(self, *excinfo):
        pass
"""# contextvars.py #"""
"""# copy.py #"""
class Error(Exception):
def copy(x):
   pass
def _copy_immutable(x):
   pass
def deepcopy(x, memo=None, _nil=[]):
   pass
def _deepcopy_atomic(x, memo):
   pass
def _deepcopy_list(x, memo, deepcopy=deepcopy):
   pass
def _deepcopy_tuple(x, memo, deepcopy=deepcopy):
   pass
def _deepcopy_dict(x, memo, deepcopy=deepcopy):
   pass
def _deepcopy_method(x, memo): # Copy instance methods
   pass
def _keep_alive(x, memo):
   pass
"""# copyreg.py #"""
def pickle(ob_type, pickle_function, constructor_ob=None):
   pass
def constructor(object):
   pass
    def pickle_complex(c):
        pass
def _reconstructor(cls, base, state):
   pass
def _reduce_ex(self, proto):
   pass
def __newobj__(cls, *args):
   pass
def __newobj_ex__(cls, args, kwargs):
   pass
def _slotnames(cls):
   pass
def add_extension(module, name, code):
   pass
def remove_extension(module, name, code):
   pass
def clear_extension_cache():
   pass
"""# cProfile.py #"""
def run(statement, filename=None, sort=-1):
   pass
def runctx(statement, globals, locals, filename=None, sort=-1):
   pass
class Profile(_lsprof.Profiler):
    def print_stats(self, sort=-1):
        pass
    def dump_stats(self, file):
        pass
    def create_stats(self):
        pass
    def snapshot_stats(self):
        pass
    def run(self, cmd):
        pass
    def runctx(self, cmd, globals, locals):
        pass
    def runcall(self, func, /, *args, **kw):
        pass
    def __enter__(self):
        pass
    def __exit__(self, *exc_info):
        pass
def label(code):
   pass
def main():
   pass
"""# crypt.py #"""
class _Method(_namedtuple('_Method', 'name ident salt_chars total_size')):
    def __repr__(self):
        pass
def mksalt(method=None, *, rounds=None):
   pass
def crypt(word, salt=None):
   pass
def _add_method(name, *args, rounds=None):
   pass
"""# csv.py #"""
class Dialect:
    def __init__(self):
        pass
    def _validate(self):
        pass
class excel(Dialect):
class excel_tab(excel):
class unix_dialect(Dialect):
class DictReader:
    def __iter__(self):
        pass
    def fieldnames(self):
        pass
    def fieldnames(self, value):
        pass
    def __next__(self):
        pass
class DictWriter:
    def writeheader(self):
        pass
    def _dict_to_list(self, rowdict):
        pass
    def writerow(self, rowdict):
        pass
    def writerows(self, rowdicts):
        pass
class Sniffer:
    def __init__(self):
        pass
    def sniff(self, sample, delimiters=None):
        pass
        class dialect(Dialect):
    def _guess_quote_and_delimiter(self, data, delimiters):
        pass
    def _guess_delimiter(self, data, delimiters):
        pass
    def has_header(self, sample):
        pass
"""# dataclasses.py #"""
class FrozenInstanceError(AttributeError): pass
class _HAS_DEFAULT_FACTORY_CLASS:
    def __repr__(self):
        pass
class _MISSING_TYPE:
class _FIELD_BASE:
    def __init__(self, name):
        pass
    def __repr__(self):
        pass
class InitVar:
    def __init__(self, type):
        pass
    def __repr__(self):
        pass
    def __class_getitem__(cls, type):
        pass
class Field:
    def __repr__(self):
        pass
    def __set_name__(self, owner, name):
        pass
class _DataclassParams:
    def __init__(self, init, repr, eq, order, unsafe_hash, frozen):
        pass
    def __repr__(self):
        pass
def _tuple_str(obj_name, fields):
   pass
def _recursive_repr(user_function):
   pass
    def wrapper(self):
        pass
def _field_assign(frozen, name, value, self_name):
   pass
def _field_init(f, frozen, globals, self_name):
   pass
def _init_param(f):
   pass
def _init_fn(fields, frozen, has_post_init, self_name, globals):
   pass
def _repr_fn(fields, globals):
   pass
def _frozen_get_del_attr(cls, fields, globals):
   pass
def _cmp_fn(name, op, self_tuple, other_tuple, globals):
   pass
def _hash_fn(fields, globals):
   pass
def _is_classvar(a_type, typing):
   pass
def _is_initvar(a_type, dataclasses):
   pass
def _is_type(annotation, cls, a_module, a_type, is_type_predicate):
   pass
def _get_field(cls, a_name, a_type):
   pass
def _set_new_attribute(cls, name, value):
   pass
def _hash_set_none(cls, fields, globals):
   pass
def _hash_add(cls, fields, globals):
   pass
def _hash_exception(cls, fields, globals):
   pass
def _process_class(cls, init, repr, eq, order, unsafe_hash, frozen):
   pass
    def wrap(cls):
        pass
def fields(class_or_instance):
   pass
def _is_dataclass_instance(obj):
   pass
def is_dataclass(obj):
   pass
def asdict(obj, *, dict_factory=dict):
   pass
      class C:
def _asdict_inner(obj, dict_factory):
   pass
def astuple(obj, *, tuple_factory=tuple):
   pass
      class C:
def _astuple_inner(obj, tuple_factory):
   pass
      class C(Base):
def replace(obj, /, **changes):
   pass
      class C:
"""# datetime.py #"""
def _cmp(x, y):
   pass
def _is_leap(year):
   pass
def _days_before_year(year):
   pass
def _days_in_month(year, month):
   pass
def _days_before_month(year, month):
   pass
def _build_struct_time(y, m, d, hh, mm, ss, dstflag):
   pass
def _format_time(hh, mm, ss, us, timespec='auto'):
   pass
def _format_offset(off):
   pass
def _wrap_strftime(object, format, timetuple):
   pass
def _parse_isoformat_date(dtstr):
   pass
def _parse_hh_mm_ss_ff(tstr):
   pass
def _parse_isoformat_time(tstr):
   pass
def _check_tzname(name):
   pass
def _check_utc_offset(name, offset):
   pass
def _check_int_field(value):
   pass
def _check_date_fields(year, month, day):
   pass
def _check_time_fields(hour, minute, second, microsecond, fold):
   pass
def _check_tzinfo_arg(tz):
   pass
def _cmperror(x, y):
   pass
def _divide_and_round(a, b):
   pass
class timedelta:
    def __repr__(self):
        pass
    def __str__(self):
        pass
            def plural(n):
                        pass
    def total_seconds(self):
        pass
    def days(self):
        pass
    def seconds(self):
        pass
    def microseconds(self):
        pass
    def __add__(self, other):
        pass
    def __sub__(self, other):
        pass
    def __rsub__(self, other):
        pass
    def __neg__(self):
        pass
    def __pos__(self):
        pass
    def __abs__(self):
        pass
    def __mul__(self, other):
        pass
    def _to_microseconds(self):
        pass
    def __floordiv__(self, other):
        pass
    def __truediv__(self, other):
        pass
    def __mod__(self, other):
        pass
    def __divmod__(self, other):
        pass
    def __eq__(self, other):
        pass
    def __le__(self, other):
        pass
    def __lt__(self, other):
        pass
    def __ge__(self, other):
        pass
    def __gt__(self, other):
        pass
    def _cmp(self, other):
        pass
    def __hash__(self):
        pass
    def __bool__(self):
        pass
    def _getstate(self):
        pass
    def __reduce__(self):
        pass
class date:
    def __new__(cls, year, month=None, day=None):
        pass
    def fromtimestamp(cls, t):
        pass
    def today(cls):
        pass
    def fromordinal(cls, n):
        pass
    def fromisoformat(cls, date_string):
        pass
    def fromisocalendar(cls, year, week, day):
        pass
    def __repr__(self):
        pass
    def ctime(self):
        pass
    def strftime(self, fmt):
        pass
    def __format__(self, fmt):
        pass
    def isoformat(self):
        pass
    def year(self):
        pass
    def month(self):
        pass
    def day(self):
        pass
    def timetuple(self):
        pass
    def toordinal(self):
        pass
    def replace(self, year=None, month=None, day=None):
        pass
    def __eq__(self, other):
        pass
    def __le__(self, other):
        pass
    def __lt__(self, other):
        pass
    def __ge__(self, other):
        pass
    def __gt__(self, other):
        pass
    def _cmp(self, other):
        pass
    def __hash__(self):
        pass
    def __add__(self, other):
        pass
    def __sub__(self, other):
        pass
    def weekday(self):
        pass
    def isoweekday(self):
        pass
    def isocalendar(self):
        pass
    def _getstate(self):
        pass
    def __setstate(self, string):
        pass
    def __reduce__(self):
        pass
class tzinfo:
    def tzname(self, dt):
        pass
    def utcoffset(self, dt):
        pass
    def dst(self, dt):
        pass
    def fromutc(self, dt):
        pass
    def __reduce__(self):
        pass
class IsoCalendarDate(tuple):
    def __new__(cls, year, week, weekday, /):
        pass
    def year(self):
        pass
    def week(self):
        pass
    def weekday(self):
        pass
    def __reduce__(self):
        pass
    def __repr__(self):
        pass
class time:
    def __new__(cls, hour=0, minute=0, second=0, microsecond=0, tzinfo=None, *, fold=0):
        pass
    def hour(self):
        pass
    def minute(self):
        pass
    def second(self):
        pass
    def microsecond(self):
        pass
    def tzinfo(self):
        pass
    def fold(self):
        pass
    def __eq__(self, other):
        pass
    def __le__(self, other):
        pass
    def __lt__(self, other):
        pass
    def __ge__(self, other):
        pass
    def __gt__(self, other):
        pass
    def _cmp(self, other, allow_mixed=False):
        pass
    def __hash__(self):
        pass
    def _tzstr(self):
        pass
    def __repr__(self):
        pass
    def isoformat(self, timespec='auto'):
        pass
    def fromisoformat(cls, time_string):
        pass
    def strftime(self, fmt):
        pass
    def __format__(self, fmt):
        pass
    def utcoffset(self):
        pass
    def tzname(self):
        pass
    def dst(self):
        pass
    def _getstate(self, protocol=3):
        pass
    def __setstate(self, string, tzinfo):
        pass
    def __reduce_ex__(self, protocol):
        pass
    def __reduce__(self):
        pass
class datetime(date):
    def hour(self):
        pass
    def minute(self):
        pass
    def second(self):
        pass
    def microsecond(self):
        pass
    def tzinfo(self):
        pass
    def fold(self):
        pass
    def _fromtimestamp(cls, t, utc, tz):
        pass
    def fromtimestamp(cls, t, tz=None):
        pass
    def utcfromtimestamp(cls, t):
        pass
    def now(cls, tz=None):
        pass
    def utcnow(cls):
        pass
    def combine(cls, date, time, tzinfo=True):
        pass
    def fromisoformat(cls, date_string):
        pass
    def timetuple(self):
        pass
    def _mktime(self):
        pass
        def local(u):
                pass
    def timestamp(self):
        pass
    def utctimetuple(self):
        pass
    def date(self):
        pass
    def time(self):
        pass
    def timetz(self):
        pass
    def _local_timezone(self):
        pass
    def astimezone(self, tz=None):
        pass
    def ctime(self):
        pass
    def isoformat(self, sep='T', timespec='auto'):
        pass
    def __repr__(self):
        pass
    def __str__(self):
        pass
    def strptime(cls, date_string, format):
        pass
    def utcoffset(self):
        pass
    def tzname(self):
        pass
    def dst(self):
        pass
    def __eq__(self, other):
        pass
    def __le__(self, other):
        pass
    def __lt__(self, other):
        pass
    def __ge__(self, other):
        pass
    def __gt__(self, other):
        pass
    def _cmp(self, other, allow_mixed=False):
        pass
    def __add__(self, other):
        pass
    def __sub__(self, other):
        pass
    def __hash__(self):
        pass
    def _getstate(self, protocol=3):
        pass
    def __setstate(self, string, tzinfo):
        pass
    def __reduce_ex__(self, protocol):
        pass
    def __reduce__(self):
        pass
class timezone(tzinfo):
    def __new__(cls, offset, name=_Omitted):
        pass
    def _create(cls, offset, name=None):
        pass
    def __getinitargs__(self):
        pass
    def __eq__(self, other):
        pass
    def __hash__(self):
        pass
    def __repr__(self):
        pass
    def __str__(self):
        pass
    def utcoffset(self, dt):
        pass
    def tzname(self, dt):
        pass
    def dst(self, dt):
        pass
    def fromutc(self, dt):
        pass
    def _name_from_offset(delta):
        pass
"""# decimal.py #"""
"""# difflib.py #"""
def _calculate_ratio(matches, length):
   pass
class SequenceMatcher:
    def __init__(self, isjunk=None, a='', b='', autojunk=True):
        pass
    def set_seqs(self, a, b):
        pass
    def __chain_b(self):
        pass
    def find_longest_match(self, alo=0, ahi=None, blo=0, bhi=None):
        pass
    def get_matching_blocks(self):
        pass
    def get_opcodes(self):
        pass
    def get_grouped_opcodes(self, n=3):
        pass
    def ratio(self):
        pass
    def quick_ratio(self):
        pass
    def real_quick_ratio(self):
        pass
def get_close_matches(word, possibilities, n=3, cutoff=0.6):
   pass
def _keep_original_ws(s, tag_s):
   pass
class Differ:
    def __init__(self, linejunk=None, charjunk=None):
        pass
    def compare(self, a, b):
        pass
    def _dump(self, tag, x, lo, hi):
        pass
    def _plain_replace(self, a, alo, ahi, b, blo, bhi):
        pass
    def _fancy_replace(self, a, alo, ahi, b, blo, bhi):
        pass
    def _fancy_helper(self, a, alo, ahi, b, blo, bhi):
        pass
    def _qformat(self, aline, bline, atags, btags):
        pass
def IS_LINE_JUNK(line, pat=re.compile(r"\s*(?:#\s*)?$").match):
   pass
def IS_CHARACTER_JUNK(ch, ws=" \t"):
   pass
def _format_range_unified(start, stop):
   pass
def _format_range_context(start, stop):
   pass
def _check_types(a, b, *args):
   pass
    def decode(s):
        pass
def ndiff(a, b, linejunk=None, charjunk=IS_CHARACTER_JUNK):
   pass
    def _make_line(lines, format_key, side, num_lines=[0,0]):
        pass
            def record_sub_info(match_object,sub_info=sub_info):
                        pass
    def _line_iterator():
        pass
    def _line_pair_iterator():
        pass
class HtmlDiff(object):
    def _tab_newline_replace(self,fromlines,tolines):
        pass
        def expand_tabs(line):
                pass
    def _split_line(self,data_list,line_num,text):
        pass
    def _line_wrapper(self,diffs):
        pass
    def _collect_lines(self,diffs):
        pass
    def _format_line(self,side,flag,linenum,text):
        pass
    def _make_prefix(self):
        pass
    def _convert_flags(self,fromlist,tolist,flaglist,context,numlines):
        pass
def restore(delta, which):
   pass
def _test():
   pass
"""# dis.py #"""
def _try_compile(source, name):
   pass
def dis(x=None, *, file=None, depth=None):
   pass
def distb(tb=None, *, file=None):
   pass
def pretty_flags(flags):
   pass
def _get_code_object(x):
   pass
def code_info(x):
   pass
def _format_code_info(co):
   pass
def show_code(co, *, file=None):
   pass
class Instruction(_Instruction):
    def _disassemble(self, lineno_width=3, mark_as_current=False, offset_width=4):
        pass
def get_instructions(x, *, first_line=None):
   pass
def _get_const_info(const_index, const_list):
   pass
def _get_name_info(name_index, name_list):
   pass
def disassemble(co, lasti=-1, *, file=None):
   pass
def _disassemble_recursive(co, *, file=None, depth=None):
   pass
def _disassemble_str(source, **kwargs):
   pass
def _unpack_opargs(code):
   pass
def findlabels(code):
   pass
def findlinestarts(code):
   pass
class Bytecode:
    def __init__(self, x, *, first_line=None, current_offset=None):
        pass
    def __iter__(self):
        pass
    def __repr__(self):
        pass
    def from_traceback(cls, tb):
        pass
    def info(self):
        pass
    def dis(self):
        pass
def _test():
   pass
"""# doctest.py #"""
def _test():
   pass
def register_optionflag(name):
   pass
def _extract_future_flags(globs):
   pass
def _normalize_module(module, depth=2):
   pass
def _newline_convert(data):
   pass
def _load_testfile(filename, package, module_relative, encoding):
   pass
def _indent(s, indent=4):
   pass
def _exception_traceback(exc_info):
   pass
class _SpoofOut(StringIO):
    def getvalue(self):
        pass
    def truncate(self, size=None):
        pass
def _ellipsis_match(want, got):
   pass
def _comment_line(line):
   pass
def _strip_exception_details(msg):
   pass
class _OutputRedirectingPdb(pdb.Pdb):
    def __init__(self, out):
        pass
    def set_trace(self, frame=None):
        pass
    def set_continue(self):
        pass
    def trace_dispatch(self, *args):
        pass
def _module_relative_path(module, test_path):
   pass
class Example:
    def __eq__(self, other):
        pass
    def __hash__(self):
        pass
class DocTest:
    def __init__(self, examples, globs, name, filename, lineno, docstring):
        pass
    def __repr__(self):
        pass
    def __eq__(self, other):
        pass
    def __hash__(self):
        pass
    def __lt__(self, other):
        pass
class DocTestParser:
    def parse(self, string, name='<string>'):
        pass
    def get_doctest(self, string, globs, name, filename, lineno):
        pass
    def get_examples(self, string, name='<string>'):
        pass
    def _parse_example(self, m, name, lineno):
        pass
    def _find_options(self, source, name, lineno):
        pass
    def _min_indent(self, s):
        pass
    def _check_prompt_blank(self, lines, indent, name, lineno):
        pass
    def _check_prefix(self, lines, prefix, name, lineno):
        pass
class DocTestFinder:
    def find(self, obj, name=None, module=None, globs=None, extraglobs=None):
        pass
    def _from_module(self, module, object):
        pass
    def _find(self, tests, obj, name, module, source_lines, globs, seen):
        pass
    def _get_test(self, obj, name, module, globs, source_lines):
        pass
    def _find_lineno(self, obj, source_lines):
        pass
class DocTestRunner:
    def __init__(self, checker=None, verbose=None, optionflags=0):
        pass
    def report_start(self, out, test, example):
        pass
    def report_success(self, out, test, example, got):
        pass
    def report_failure(self, out, test, example, got):
        pass
    def report_unexpected_exception(self, out, test, example, exc_info):
        pass
    def _failure_header(self, test, example):
        pass
    def __run(self, test, compileflags, out):
        pass
    def __record_outcome(self, test, f, t):
        pass
    def __patched_linecache_getlines(self, filename, module_globals=None):
        pass
    def run(self, test, compileflags=None, out=None, clear_globs=True):
        pass
                def out(s):
                                pass
    def summarize(self, verbose=None):
        pass
    def merge(self, other):
        pass
class OutputChecker:
    def _toAscii(self, s):
        pass
    def check_output(self, want, got, optionflags):
        pass
    def _do_a_fancy_diff(self, want, got, optionflags):
        pass
    def output_difference(self, example, got, optionflags):
        pass
class DocTestFailure(Exception):
    def __init__(self, test, example, got):
        pass
    def __str__(self):
        pass
class UnexpectedException(Exception):
    def __init__(self, test, example, exc_info):
        pass
    def __str__(self):
        pass
class DebugRunner(DocTestRunner):
    def run(self, test, compileflags=None, out=None, clear_globs=True):
        pass
    def report_unexpected_exception(self, out, test, example, exc_info):
        pass
    def report_failure(self, out, test, example, got):
        pass
def set_unittest_reportflags(flags):
   pass
class DocTestCase(unittest.TestCase):
    def setUp(self):
        pass
    def tearDown(self):
        pass
    def runTest(self):
        pass
    def format_failure(self, err):
        pass
    def debug(self):
        pass
    def id(self):
        pass
    def __eq__(self, other):
        pass
    def __hash__(self):
        pass
    def __repr__(self):
        pass
    def shortDescription(self):
        pass
class SkipDocTestCase(DocTestCase):
    def __init__(self, module):
        pass
    def setUp(self):
        pass
    def test_skip(self):
        pass
    def shortDescription(self):
        pass
class _DocTestSuite(unittest.TestSuite):
    def _removeTestAtIndex(self, index):
        pass
class DocFileCase(DocTestCase):
    def id(self):
        pass
    def __repr__(self):
        pass
    def format_failure(self, err):
        pass
def DocFileSuite(*paths, **kw):
   pass
def script_from_examples(s):
   pass
def testsource(module, name):
   pass
def debug_src(src, pm=False, globs=None):
   pass
def debug_script(src, pm=False, globs=None):
   pass
def debug(module, name, pm=False):
   pass
class _TestClass:
    def __init__(self, val):
        pass
    def square(self):
        pass
    def get(self):
        pass
def _test():
   pass
"""# enum.py #"""
def _is_descriptor(obj):
   pass
def _is_dunder(name):
   pass
def _is_sunder(name):
   pass
def _make_class_unpicklable(cls):
   pass
    def _break_on_call_reduce(self, proto):
        pass
class auto:
class _EnumDict(dict):
    def __init__(self):
        pass
    def __setitem__(self, key, value):
        pass
class EnumMeta(type):
    def __prepare__(metacls, cls, bases):
        pass
    def __new__(metacls, cls, bases, classdict):
        pass
    def __bool__(self):
        pass
    def __call__(cls, value, names=None, *, module=None, qualname=None, type=None, start=1):
        pass
    def __contains__(cls, member):
        pass
    def __delattr__(cls, attr):
        pass
    def __dir__(self):
        pass
    def __getattr__(cls, name):
        pass
    def __getitem__(cls, name):
        pass
    def __iter__(cls):
        pass
    def __len__(cls):
        pass
    def __members__(cls):
        pass
    def __repr__(cls):
        pass
    def __reversed__(cls):
        pass
    def __setattr__(cls, name, value):
        pass
    def _create_(cls, class_name, names, *, module=None, qualname=None, type=None, start=1):
        pass
    def _convert_(cls, name, module, filter, source=None):
        pass
    def _check_for_existing_members(class_name, bases):
        pass
    def _get_mixins_(class_name, bases):
        pass
        def _find_data_type(bases):
                pass
    def _find_new_(classdict, member_type, first_enum):
        pass
class Enum(metaclass=EnumMeta):
    def __new__(cls, value):
        pass
    def _generate_next_value_(name, start, count, last_values):
        pass
    def _missing_(cls, value):
        pass
    def __repr__(self):
        pass
    def __str__(self):
        pass
    def __dir__(self):
        pass
    def __format__(self, format_spec):
        pass
    def __hash__(self):
        pass
    def __reduce_ex__(self, proto):
        pass
    def name(self):
        pass
    def value(self):
        pass
class IntEnum(int, Enum):
def _reduce_ex_by_name(self, proto):
   pass
class Flag(Enum):
    def _generate_next_value_(name, start, count, last_values):
        pass
    def _missing_(cls, value):
        pass
    def _create_pseudo_member_(cls, value):
        pass
    def __contains__(self, other):
        pass
    def __repr__(self):
        pass
    def __str__(self):
        pass
    def __bool__(self):
        pass
    def __or__(self, other):
        pass
    def __and__(self, other):
        pass
    def __xor__(self, other):
        pass
    def __invert__(self):
        pass
class IntFlag(int, Flag):
    def _missing_(cls, value):
        pass
    def _create_pseudo_member_(cls, value):
        pass
    def __or__(self, other):
        pass
    def __and__(self, other):
        pass
    def __xor__(self, other):
        pass
    def __invert__(self):
        pass
def _high_bit(value):
   pass
def unique(enumeration):
   pass
def _decompose(flag, value):
   pass
"""# filecmp.py #"""
def clear_cache():
   pass
def cmp(f1, f2, shallow=True):
   pass
def _sig(st):
   pass
def _do_cmp(f1, f2):
   pass
class dircmp:
    def __init__(self, a, b, ignore=None, hide=None): # Initialize
        pass
    def report(self): # Print a report on the differences between a and b
        pass
    def report_partial_closure(self): # Print reports on self and on subdirs
        pass
    def report_full_closure(self): # Report on self and subdirs recursively
        pass
    def __getattr__(self, attr):
        pass
def cmpfiles(a, b, common, shallow=True):
   pass
def _cmp(a, b, sh, abs=abs, cmp=cmp):
   pass
def _filter(flist, skip):
   pass
def demo():
   pass
"""# fileinput.py #"""
def input(files=None, inplace=False, backup="", *, mode="r", openhook=None):
   pass
def close():
   pass
def nextfile():
   pass
def filename():
   pass
def lineno():
   pass
def filelineno():
   pass
def fileno():
   pass
def isfirstline():
   pass
def isstdin():
   pass
class FileInput:
    def __del__(self):
        pass
    def close(self):
        pass
    def __enter__(self):
        pass
    def __exit__(self, type, value, traceback):
        pass
    def __iter__(self):
        pass
    def __next__(self):
        pass
    def __getitem__(self, i):
        pass
    def nextfile(self):
        pass
    def readline(self):
        pass
    def _readline(self):
        pass
    def filename(self):
        pass
    def lineno(self):
        pass
    def filelineno(self):
        pass
    def fileno(self):
        pass
    def isfirstline(self):
        pass
    def isstdin(self):
        pass
def hook_compressed(filename, mode):
   pass
def hook_encoded(encoding, errors=None):
   pass
    def openhook(filename, mode):
        pass
def _test():
   pass
"""# fnmatch.py #"""
def fnmatch(name, pat):
   pass
def _compile_pattern(pat):
   pass
def filter(names, pat):
   pass
def fnmatchcase(name, pat):
   pass
def translate(pat):
   pass
"""# formatter.py #"""
class NullFormatter:
    def __init__(self, writer=None):
        pass
    def end_paragraph(self, blankline): pass
        pass
    def add_line_break(self): pass
        pass
    def add_hor_rule(self, *args, **kw): pass
        pass
    def add_label_data(self, format, counter, blankline=None): pass
        pass
    def add_flowing_data(self, data): pass
        pass
    def add_literal_data(self, data): pass
        pass
    def flush_softspace(self): pass
        pass
    def push_alignment(self, align): pass
        pass
    def pop_alignment(self): pass
        pass
    def push_font(self, x): pass
        pass
    def pop_font(self): pass
        pass
    def push_margin(self, margin): pass
        pass
    def pop_margin(self): pass
        pass
    def set_spacing(self, spacing): pass
        pass
    def push_style(self, *styles): pass
        pass
    def pop_style(self, n=1): pass
        pass
    def assert_line_data(self, flag=1): pass
        pass
class AbstractFormatter:
    def __init__(self, writer):
        pass
    def end_paragraph(self, blankline):
        pass
    def add_line_break(self):
        pass
    def add_hor_rule(self, *args, **kw):
        pass
    def add_label_data(self, format, counter, blankline = None):
        pass
    def format_counter(self, format, counter):
        pass
    def format_letter(self, case, counter):
        pass
    def format_roman(self, case, counter):
        pass
    def add_flowing_data(self, data):
        pass
    def add_literal_data(self, data):
        pass
    def flush_softspace(self):
        pass
    def push_alignment(self, align):
        pass
    def pop_alignment(self):
        pass
    def push_font(self, font):
        pass
    def pop_font(self):
        pass
    def push_margin(self, margin):
        pass
    def pop_margin(self):
        pass
    def set_spacing(self, spacing):
        pass
    def push_style(self, *styles):
        pass
    def pop_style(self, n=1):
        pass
    def assert_line_data(self, flag=1):
        pass
class NullWriter:
    def __init__(self): pass
        pass
    def flush(self): pass
        pass
    def new_alignment(self, align): pass
        pass
    def new_font(self, font): pass
        pass
    def new_margin(self, margin, level): pass
        pass
    def new_spacing(self, spacing): pass
        pass
    def new_styles(self, styles): pass
        pass
    def send_paragraph(self, blankline): pass
        pass
    def send_line_break(self): pass
        pass
    def send_hor_rule(self, *args, **kw): pass
        pass
    def send_label_data(self, data): pass
        pass
    def send_flowing_data(self, data): pass
        pass
    def send_literal_data(self, data): pass
        pass
class AbstractWriter(NullWriter):
    def new_alignment(self, align):
        pass
    def new_font(self, font):
        pass
    def new_margin(self, margin, level):
        pass
    def new_spacing(self, spacing):
        pass
    def new_styles(self, styles):
        pass
    def send_paragraph(self, blankline):
        pass
    def send_line_break(self):
        pass
    def send_hor_rule(self, *args, **kw):
        pass
    def send_label_data(self, data):
        pass
    def send_flowing_data(self, data):
        pass
    def send_literal_data(self, data):
        pass
class DumbWriter(NullWriter):
    def __init__(self, file=None, maxcol=72):
        pass
    def reset(self):
        pass
    def send_paragraph(self, blankline):
        pass
    def send_line_break(self):
        pass
    def send_hor_rule(self, *args, **kw):
        pass
    def send_literal_data(self, data):
        pass
    def send_flowing_data(self, data):
        pass
def test(file = None):
   pass
"""# fractions.py #"""
class Fraction(numbers.Rational):
    def __new__(cls, numerator=0, denominator=None, *, _normalize=True):
        pass
    def from_float(cls, f):
        pass
    def from_decimal(cls, dec):
        pass
    def as_integer_ratio(self):
        pass
    def limit_denominator(self, max_denominator=1000000):
        pass
    def numerator(a):
        pass
    def denominator(a):
        pass
    def __repr__(self):
        pass
    def __str__(self):
        pass
    def _operator_fallbacks(monomorphic_operator, fallback_operator):
        pass
            def __add__(self, other):
                        pass
            def __radd__(self, other):
                        pass
        def forward(a, b):
                pass
        def reverse(b, a):
                pass
    def _add(a, b):
        pass
    def _sub(a, b):
        pass
    def _mul(a, b):
        pass
    def _div(a, b):
        pass
    def _floordiv(a, b):
        pass
    def _divmod(a, b):
        pass
    def _mod(a, b):
        pass
    def __pow__(a, b):
        pass
    def __rpow__(b, a):
        pass
    def __pos__(a):
        pass
    def __neg__(a):
        pass
    def __abs__(a):
        pass
    def __trunc__(a):
        pass
    def __floor__(a):
        pass
    def __ceil__(a):
        pass
    def __round__(self, ndigits=None):
        pass
    def __hash__(self):
        pass
    def __eq__(a, b):
        pass
    def _richcmp(self, other, op):
        pass
    def __lt__(a, b):
        pass
    def __gt__(a, b):
        pass
    def __le__(a, b):
        pass
    def __ge__(a, b):
        pass
    def __bool__(a):
        pass
    def __reduce__(self):
        pass
    def __copy__(self):
        pass
    def __deepcopy__(self, memo):
        pass
"""# ftplib.py #"""
class Error(Exception): pass
class error_reply(Error): pass          # unexpected [123]xx reply
class error_temp(Error): pass           # 4xx errors
class error_perm(Error): pass           # 5xx errors
class error_proto(Error): pass          # response does not begin with [1-5]
class FTP:
    def __enter__(self):
        pass
    def __exit__(self, *args):
        pass
    def connect(self, host='', port=0, timeout=-999, source_address=None):
        pass
    def getwelcome(self):
        pass
    def set_debuglevel(self, level):
        pass
    def set_pasv(self, val):
        pass
    def sanitize(self, s):
        pass
    def putline(self, line):
        pass
    def putcmd(self, line):
        pass
    def getline(self):
        pass
    def getmultiline(self):
        pass
    def getresp(self):
        pass
    def voidresp(self):
        pass
    def abort(self):
        pass
    def sendcmd(self, cmd):
        pass
    def voidcmd(self, cmd):
        pass
    def sendport(self, host, port):
        pass
    def sendeprt(self, host, port):
        pass
    def makeport(self):
        pass
    def makepasv(self):
        pass
    def ntransfercmd(self, cmd, rest=None):
        pass
    def transfercmd(self, cmd, rest=None):
        pass
    def login(self, user = '', passwd = '', acct = ''):
        pass
    def retrbinary(self, cmd, callback, blocksize=8192, rest=None):
        pass
    def retrlines(self, cmd, callback = None):
        pass
    def storbinary(self, cmd, fp, blocksize=8192, callback=None, rest=None):
        pass
    def storlines(self, cmd, fp, callback=None):
        pass
    def acct(self, password):
        pass
    def nlst(self, *args):
        pass
    def dir(self, *args):
        pass
    def mlsd(self, path="", facts=[]):
        pass
    def rename(self, fromname, toname):
        pass
    def delete(self, filename):
        pass
    def cwd(self, dirname):
        pass
    def size(self, filename):
        pass
    def mkd(self, dirname):
        pass
    def rmd(self, dirname):
        pass
    def pwd(self):
        pass
    def quit(self):
        pass
    def close(self):
        pass
    class FTP_TLS(FTP):
        def login(self, user='', passwd='', acct='', secure=True):
                pass
        def auth(self):
                pass
        def ccc(self):
                pass
        def prot_p(self):
                pass
        def prot_c(self):
                pass
        def ntransfercmd(self, cmd, rest=None):
                pass
        def abort(self):
                pass
def print_line(line):
   pass
def ftpcp(source, sourcename, target, targetname = '', type = 'I'):
   pass
def test():
   pass
"""# functools.py #"""
"""# genericpath.py #"""
def exists(path):
   pass
def isfile(path):
   pass
def isdir(s):
   pass
def getsize(filename):
   pass
def getmtime(filename):
   pass
def getatime(filename):
   pass
def getctime(filename):
   pass
def commonprefix(m):
   pass
def samestat(s1, s2):
   pass
def samefile(f1, f2):
   pass
def sameopenfile(fp1, fp2):
   pass
def _splitext(p, sep, altsep, extsep):
   pass
def _check_arg_types(funcname, *args):
   pass
"""# getopt.py #"""
    def _(s): return s
        pass
class GetoptError(Exception):
    def __init__(self, msg, opt=''):
        pass
    def __str__(self):
        pass
def getopt(args, shortopts, longopts = []):
   pass
def gnu_getopt(args, shortopts, longopts = []):
   pass
def do_longs(opts, opt, longopts, args):
   pass
def long_has_args(opt, longopts):
   pass
def do_shorts(opts, optstring, shortopts, args):
   pass
def short_has_arg(opt, shortopts):
   pass
"""# getpass.py #"""
class GetPassWarning(UserWarning): pass
def unix_getpass(prompt='Password: ', stream=None):
   pass
def win_getpass(prompt='Password: ', stream=None):
   pass
def fallback_getpass(prompt='Password: ', stream=None):
   pass
def _raw_input(prompt="", stream=None, input=None):
   pass
def getuser():
   pass
"""# gettext.py #"""
def _tokenize(plural):
   pass
def _error(value):
   pass
def _parse(tokens, priority=-1):
   pass
def _as_int(n):
   pass
            def func(n):
                        pass
def _expand_lang(loc):
   pass
class NullTranslations:
    def __init__(self, fp=None):
        pass
    def _parse(self, fp):
        pass
    def add_fallback(self, fallback):
        pass
    def gettext(self, message):
        pass
    def lgettext(self, message):
        pass
    def ngettext(self, msgid1, msgid2, n):
        pass
    def lngettext(self, msgid1, msgid2, n):
        pass
    def pgettext(self, context, message):
        pass
    def npgettext(self, context, msgid1, msgid2, n):
        pass
    def info(self):
        pass
    def charset(self):
        pass
    def output_charset(self):
        pass
    def set_output_charset(self, charset):
        pass
    def install(self, names=None):
        pass
class GNUTranslations(NullTranslations):
    def _get_versions(self, version):
        pass
    def _parse(self, fp):
        pass
    def lgettext(self, message):
        pass
    def lngettext(self, msgid1, msgid2, n):
        pass
    def gettext(self, message):
        pass
    def ngettext(self, msgid1, msgid2, n):
        pass
    def pgettext(self, context, message):
        pass
    def npgettext(self, context, msgid1, msgid2, n):
        pass
def find(domain, localedir=None, languages=None, all=False):
   pass
def install(domain, localedir=None, codeset=_unspecified, names=None):
   pass
def textdomain(domain=None):
   pass
def bindtextdomain(domain, localedir=None):
   pass
def bind_textdomain_codeset(domain, codeset=None):
   pass
def dgettext(domain, message):
   pass
def ldgettext(domain, message):
   pass
def dngettext(domain, msgid1, msgid2, n):
   pass
def ldngettext(domain, msgid1, msgid2, n):
   pass
def dpgettext(domain, context, message):
   pass
def dnpgettext(domain, context, msgid1, msgid2, n):
   pass
def gettext(message):
   pass
def lgettext(message):
   pass
def ngettext(msgid1, msgid2, n):
   pass
def lngettext(msgid1, msgid2, n):
   pass
def pgettext(context, message):
   pass
def npgettext(context, msgid1, msgid2, n):
   pass
"""# glob.py #"""
def glob(pathname, *, recursive=False):
   pass
def iglob(pathname, *, recursive=False):
   pass
def _iglob(pathname, recursive, dironly):
   pass
def _iterdir(dirname, dironly):
   pass
def _rlistdir(dirname, dironly):
   pass
def has_magic(s):
   pass
def _ishidden(path):
   pass
def _isrecursive(pattern):
   pass
def escape(pathname):
   pass
"""# graphlib.py #"""
class _NodeInfo:
    def __init__(self, node):
        pass
class CycleError(ValueError):
class TopologicalSorter:
    def __init__(self, graph=None):
        pass
    def _get_nodeinfo(self, node):
        pass
    def add(self, node, *predecessors):
        pass
    def prepare(self):
        pass
    def get_ready(self):
        pass
    def is_active(self):
        pass
    def __bool__(self):
        pass
    def done(self, *nodes):
        pass
    def _find_cycle(self):
        pass
    def static_order(self):
        pass
"""# gzip.py #"""
class _PaddedFile:
    def __init__(self, f, prepend=b''):
        pass
    def read(self, size):
        pass
    def prepend(self, prepend=b''):
        pass
    def seek(self, off):
        pass
    def seekable(self):
        pass
class BadGzipFile(OSError):
class GzipFile(_compression.BaseStream):
    def filename(self):
        pass
    def mtime(self):
        pass
    def __repr__(self):
        pass
    def _init_write(self, filename):
        pass
    def _write_gzip_header(self, compresslevel):
        pass
    def write(self,data):
        pass
    def read(self, size=-1):
        pass
    def peek(self, n):
        pass
    def closed(self):
        pass
    def close(self):
        pass
    def flush(self,zlib_mode=zlib.Z_SYNC_FLUSH):
        pass
    def fileno(self):
        pass
    def rewind(self):
        pass
    def readable(self):
        pass
    def writable(self):
        pass
    def seekable(self):
        pass
    def seek(self, offset, whence=io.SEEK_SET):
        pass
    def readline(self, size=-1):
        pass
class _GzipReader(_compression.DecompressReader):
    def __init__(self, fp):
        pass
    def _init_read(self):
        pass
    def _read_exact(self, n):
        pass
    def _read_gzip_header(self):
        pass
    def read(self, size=-1):
        pass
    def _add_read_data(self, data):
        pass
    def _read_eof(self):
        pass
    def _rewind(self):
        pass
def compress(data, compresslevel=_COMPRESS_LEVEL_BEST, *, mtime=None):
   pass
def decompress(data):
   pass
def main():
   pass
"""# hashlib.py #"""
def __get_builtin_constructor(name):
   pass
def __get_openssl_constructor(name):
   pass
def __py_new(name, data=b'', **kwargs):
   pass
def __hash_new(name, data=b'', **kwargs):
   pass
        def prf(msg, inner=inner, outer=outer):
                pass
"""# heapq.py #"""
def heappush(heap, item):
   pass
def heappop(heap):
   pass
def heapreplace(heap, item):
   pass
def heappushpop(heap, item):
   pass
def heapify(x):
   pass
def _heappop_max(heap):
   pass
def _heapreplace_max(heap, item):
   pass
def _heapify_max(x):
   pass
def _siftdown(heap, startpos, pos):
   pass
def _siftup(heap, pos):
   pass
def _siftdown_max(heap, startpos, pos):
   pass
def _siftup_max(heap, pos):
   pass
def merge(*iterables, key=None, reverse=False):
   pass
def nsmallest(n, iterable, key=None):
   pass
def nlargest(n, iterable, key=None):
   pass
"""# hmac.py #"""
class HMAC:
    def __init__(self, key, msg=None, digestmod=''):
        pass
    def name(self):
        pass
    def digest_cons(self):
        pass
    def inner(self):
        pass
    def outer(self):
        pass
    def update(self, msg):
        pass
    def copy(self):
        pass
    def _current(self):
        pass
    def digest(self):
        pass
    def hexdigest(self):
        pass
def new(key, msg=None, digestmod=''):
   pass
def digest(key, msg, digest):
   pass
"""# imaplib.py #"""
    class error(Exception): pass    # Logical errors - debug required
    class abort(error): pass        # Service errors - close and retry
    class readonly(abort): pass     # Mailbox status changed to READ-ONLY
    def __init__(self, host='', port=IMAP4_PORT, timeout=None):
        pass
    def _mode_ascii(self):
        pass
    def _connect(self):
        pass
    def __getattr__(self, attr):
        pass
    def __enter__(self):
        pass
    def __exit__(self, *args):
        pass
    def _create_socket(self, timeout):
        pass
    def open(self, host='', port=IMAP4_PORT, timeout=None):
        pass
    def read(self, size):
        pass
    def readline(self):
        pass
    def send(self, data):
        pass
    def shutdown(self):
        pass
    def socket(self):
        pass
    def recent(self):
        pass
    def response(self, code):
        pass
    def append(self, mailbox, flags, date_time, message):
        pass
    def authenticate(self, mechanism, authobject):
        pass
    def capability(self):
        pass
    def check(self):
        pass
    def close(self):
        pass
    def copy(self, message_set, new_mailbox):
        pass
    def create(self, mailbox):
        pass
    def delete(self, mailbox):
        pass
    def deleteacl(self, mailbox, who):
        pass
    def enable(self, capability):
        pass
    def expunge(self):
        pass
    def fetch(self, message_set, message_parts):
        pass
    def getacl(self, mailbox):
        pass
    def getannotation(self, mailbox, entry, attribute):
        pass
    def getquota(self, root):
        pass
    def getquotaroot(self, mailbox):
        pass
    def list(self, directory='""', pattern='*'):
        pass
    def login(self, user, password):
        pass
    def logout(self):
        pass
    def lsub(self, directory='""', pattern='*'):
        pass
    def myrights(self, mailbox):
        pass
    def namespace(self):
        pass
    def noop(self):
        pass
    def partial(self, message_num, message_part, start, length):
        pass
    def proxyauth(self, user):
        pass
    def rename(self, oldmailbox, newmailbox):
        pass
    def search(self, charset, *criteria):
        pass
    def select(self, mailbox='INBOX', readonly=False):
        pass
    def setacl(self, mailbox, who, what):
        pass
    def setannotation(self, *args):
        pass
    def setquota(self, root, limits):
        pass
    def sort(self, sort_criteria, charset, *search_criteria):
        pass
    def starttls(self, ssl_context=None):
        pass
    def status(self, mailbox, names):
        pass
    def store(self, message_set, command, flags):
        pass
    def subscribe(self, mailbox):
        pass
    def thread(self, threading_algorithm, charset, *search_criteria):
        pass
    def uid(self, command, *args):
        pass
    def unsubscribe(self, mailbox):
        pass
    def unselect(self):
        pass
    def xatom(self, name, *args):
        pass
    def _append_untagged(self, typ, dat):
        pass
    def _check_bye(self):
        pass
    def _command(self, name, *args):
        pass
    def _command_complete(self, name, tag):
        pass
    def _get_capabilities(self):
        pass
    def _get_response(self):
        pass
    def _get_tagged_response(self, tag, expect_bye=False):
        pass
    def _get_line(self):
        pass
    def _match(self, cre, s):
        pass
    def _new_tag(self):
        pass
    def _quote(self, arg):
        pass
    def _simple_command(self, name, *args):
        pass
    def _untagged_response(self, typ, dat, name):
        pass
        def _mesg(self, s, secs=None):
                pass
        def _dump_ur(self, dict):
                pass
        def _log(self, line):
                pass
        def print_log(self):
                pass
        def _create_socket(self, timeout):
                pass
        def open(self, host='', port=IMAP4_SSL_PORT, timeout=None):
                pass
    def __init__(self, command):
        pass
    def open(self, host=None, port=None, timeout=None):
        pass
    def read(self, size):
        pass
    def readline(self):
        pass
    def send(self, data):
        pass
    def shutdown(self):
        pass
class _Authenticator:
    def __init__(self, mechinst):
        pass
    def process(self, data):
        pass
    def encode(self, inp):
        pass
    def decode(self, inp):
        pass
def ParseFlags(resp):
   pass
    def run(cmd, args):
        pass
"""# imghdr.py #"""
def what(file, h=None):
   pass
def test_jpeg(h, f):
   pass
def test_png(h, f):
   pass
def test_gif(h, f):
   pass
def test_tiff(h, f):
   pass
def test_rgb(h, f):
   pass
def test_pbm(h, f):
   pass
def test_pgm(h, f):
   pass
def test_ppm(h, f):
   pass
def test_rast(h, f):
   pass
def test_xbm(h, f):
   pass
def test_bmp(h, f):
   pass
def test_webp(h, f):
   pass
def test_exr(h, f):
   pass
def test():
   pass
def testall(list, recursive, toplevel):
   pass
"""# imp.py #"""
def new_module(name):
   pass
def get_magic():
   pass
def get_tag():
   pass
def cache_from_source(path, debug_override=None):
   pass
def source_from_cache(path):
   pass
def get_suffixes():
   pass
class NullImporter:
    def __init__(self, path):
        pass
    def find_module(self, fullname):
        pass
class _HackedGetData:
    def __init__(self, fullname, path, file=None):
        pass
    def get_data(self, path):
        pass
class _LoadSourceCompatibility(_HackedGetData, machinery.SourceFileLoader):
def load_source(name, pathname, file=None):
   pass
class _LoadCompiledCompatibility(_HackedGetData, SourcelessFileLoader):
def load_compiled(name, pathname, file=None):
   pass
def load_package(name, path):
   pass
def load_module(name, file, filename, details):
   pass
def find_module(name, path=None):
   pass
def reload(module):
   pass
def init_builtin(name):
   pass
    def load_dynamic(name, path, file=None):
        pass
"""# inspect.py #"""
def ismodule(object):
   pass
def isclass(object):
   pass
def ismethod(object):
   pass
def ismethoddescriptor(object):
   pass
def isdatadescriptor(object):
   pass
    def ismemberdescriptor(object):
        pass
    def ismemberdescriptor(object):
        pass
    def isgetsetdescriptor(object):
        pass
    def isgetsetdescriptor(object):
        pass
def isfunction(object):
   pass
def _has_code_flag(f, flag):
   pass
def isgeneratorfunction(obj):
   pass
def iscoroutinefunction(obj):
   pass
def isasyncgenfunction(obj):
   pass
def isasyncgen(object):
   pass
def isgenerator(object):
   pass
def iscoroutine(object):
   pass
def isawaitable(object):
   pass
def istraceback(object):
   pass
def isframe(object):
   pass
def iscode(object):
   pass
def isbuiltin(object):
   pass
def isroutine(object):
   pass
def isabstract(object):
   pass
def getmembers(object, predicate=None):
   pass
def classify_class_attrs(cls):
   pass
def getmro(cls):
   pass
def unwrap(func, *, stop=None):
   pass
        def _is_wrapper(f):
                pass
        def _is_wrapper(f):
                pass
def indentsize(line):
   pass
def _findclass(func):
   pass
def _finddoc(obj):
   pass
def getdoc(object):
   pass
def cleandoc(doc):
   pass
def getfile(object):
   pass
def getmodulename(path):
   pass
def getsourcefile(object):
   pass
def getabsfile(object, _filename=None):
   pass
def getmodule(object, _filename=None):
   pass
class ClassFoundException(Exception):
class _ClassFinder(ast.NodeVisitor):
    def __init__(self, qualname):
        pass
    def visit_FunctionDef(self, node):
        pass
    def visit_ClassDef(self, node):
        pass
def findsource(object):
   pass
def getcomments(object):
   pass
class EndOfBlock(Exception): pass
class BlockFinder:
    def __init__(self):
        pass
    def tokeneater(self, type, token, srowcol, erowcol, line):
        pass
def getblock(lines):
   pass
def getsourcelines(object):
   pass
def getsource(object):
   pass
def walktree(classes, children, parent):
   pass
def getclasstree(classes, unique=False):
   pass
def getargs(co):
   pass
def getargspec(func):
   pass
def getfullargspec(func):
   pass
def getargvalues(frame):
   pass
def formatannotation(annotation, base_module=None):
   pass
def formatannotationrelativeto(object):
   pass
    def _formatannotation(annotation):
        pass
    def formatargandannotation(arg):
        pass
def _missing_arguments(f_name, argnames, pos, values):
   pass
def _too_many(f_name, args, kwonly, varargs, defcount, given, values):
   pass
def getcallargs(func, /, *positional, **named):
   pass
def getclosurevars(func):
   pass
def getframeinfo(frame, context=1):
   pass
def getlineno(frame):
   pass
def getouterframes(frame, context=1):
   pass
def getinnerframes(tb, context=1):
   pass
def currentframe():
   pass
def stack(context=1):
   pass
def trace(context=1):
   pass
def _static_getmro(klass):
   pass
def _check_instance(obj, attr):
   pass
def _check_class(klass, attr):
   pass
def _is_type(obj):
   pass
def _shadowed_dict(klass):
   pass
def getattr_static(obj, attr, default=_sentinel):
   pass
def getgeneratorstate(generator):
   pass
def getgeneratorlocals(generator):
   pass
def getcoroutinestate(coroutine):
   pass
def getcoroutinelocals(coroutine):
   pass
def _signature_get_user_defined_method(cls, method_name):
   pass
def _signature_get_partial(wrapped_sig, partial, extra_args=()):
   pass
def _signature_bound_method(sig):
   pass
def _signature_is_builtin(obj):
   pass
def _signature_is_functionlike(obj):
   pass
def _signature_get_bound_param(spec):
   pass
def _signature_strip_non_python_syntax(signature):
   pass
def _signature_fromstr(cls, obj, s, skip_bound_arg=True):
   pass
    def parse_name(node):
        pass
    def wrap_value(s):
        pass
    class RewriteSymbolics(ast.NodeTransformer):
        def visit_Attribute(self, node):
                pass
        def visit_Name(self, node):
                pass
    def p(name_node, default_node, default=empty):
        pass
def _signature_from_builtin(cls, func, skip_bound_arg=True):
   pass
def _signature_from_function(cls, func, skip_bound_arg=True):
   pass
class _void:
class _empty:
class _ParameterKind(enum.IntEnum):
    def __str__(self):
        pass
    def description(self):
        pass
class Parameter:
    def __init__(self, name, kind, *, default=_empty, annotation=_empty):
        pass
    def __reduce__(self):
        pass
    def __setstate__(self, state):
        pass
    def name(self):
        pass
    def default(self):
        pass
    def annotation(self):
        pass
    def kind(self):
        pass
    def __str__(self):
        pass
    def __repr__(self):
        pass
    def __hash__(self):
        pass
    def __eq__(self, other):
        pass
class BoundArguments:
    def __init__(self, signature, arguments):
        pass
    def signature(self):
        pass
    def args(self):
        pass
    def kwargs(self):
        pass
    def apply_defaults(self):
        pass
    def __eq__(self, other):
        pass
    def __setstate__(self, state):
        pass
    def __getstate__(self):
        pass
    def __repr__(self):
        pass
class Signature:
    def from_function(cls, func):
        pass
    def from_builtin(cls, func):
        pass
    def from_callable(cls, obj, *, follow_wrapped=True):
        pass
    def parameters(self):
        pass
    def return_annotation(self):
        pass
    def replace(self, *, parameters=_void, return_annotation=_void):
        pass
    def _hash_basis(self):
        pass
    def __hash__(self):
        pass
    def __eq__(self, other):
        pass
    def _bind(self, args, kwargs, *, partial=False):
        pass
    def bind(self, /, *args, **kwargs):
        pass
    def bind_partial(self, /, *args, **kwargs):
        pass
    def __reduce__(self):
        pass
    def __setstate__(self, state):
        pass
    def __repr__(self):
        pass
    def __str__(self):
        pass
def signature(obj, *, follow_wrapped=True):
   pass
def _main():
   pass
"""# io.py #"""
class IOBase(_io._IOBase, metaclass=abc.ABCMeta):
class RawIOBase(_io._RawIOBase, IOBase):
class BufferedIOBase(_io._BufferedIOBase, IOBase):
class TextIOBase(_io._TextIOBase, IOBase):
"""# ipaddress.py #"""
class AddressValueError(ValueError):
class NetmaskValueError(ValueError):
def ip_address(address):
   pass
def ip_network(address, strict=True):
   pass
def ip_interface(address):
   pass
def _split_optional_netmask(address):
   pass
def _find_address_range(addresses):
   pass
def _count_righthand_zero_bits(number, bits):
   pass
def summarize_address_range(first, last):
   pass
def _collapse_addresses_internal(addresses):
   pass
def collapse_addresses(addresses):
   pass
def get_mixed_type_key(obj):
   pass
class _IPAddressBase:
    def exploded(self):
        pass
    def compressed(self):
        pass
    def reverse_pointer(self):
        pass
    def version(self):
        pass
    def _check_int_address(self, address):
        pass
    def _check_packed_address(self, address, expected_len):
        pass
    def _ip_int_from_prefix(cls, prefixlen):
        pass
    def _prefix_from_ip_int(cls, ip_int):
        pass
    def _report_invalid_netmask(cls, netmask_str):
        pass
    def _prefix_from_prefix_string(cls, prefixlen_str):
        pass
    def _prefix_from_ip_string(cls, ip_str):
        pass
    def _split_addr_prefix(cls, address):
        pass
    def __reduce__(self):
        pass
class _BaseAddress(_IPAddressBase):
    def __int__(self):
        pass
    def __eq__(self, other):
        pass
    def __lt__(self, other):
        pass
    def __add__(self, other):
        pass
    def __sub__(self, other):
        pass
    def __repr__(self):
        pass
    def __str__(self):
        pass
    def __hash__(self):
        pass
    def _get_address_key(self):
        pass
    def __reduce__(self):
        pass
    def __format__(self, fmt):
        pass
class _BaseNetwork(_IPAddressBase):
    def __repr__(self):
        pass
    def __str__(self):
        pass
    def hosts(self):
        pass
    def __iter__(self):
        pass
    def __getitem__(self, n):
        pass
    def __lt__(self, other):
        pass
    def __eq__(self, other):
        pass
    def __hash__(self):
        pass
    def __contains__(self, other):
        pass
    def overlaps(self, other):
        pass
    def broadcast_address(self):
        pass
    def hostmask(self):
        pass
    def with_prefixlen(self):
        pass
    def with_netmask(self):
        pass
    def with_hostmask(self):
        pass
    def num_addresses(self):
        pass
    def _address_class(self):
        pass
    def prefixlen(self):
        pass
    def address_exclude(self, other):
        pass
    def compare_networks(self, other):
        pass
    def _get_networks_key(self):
        pass
    def subnets(self, prefixlen_diff=1, new_prefix=None):
        pass
    def supernet(self, prefixlen_diff=1, new_prefix=None):
        pass
    def is_multicast(self):
        pass
    def _is_subnet_of(a, b):
        pass
    def subnet_of(self, other):
        pass
    def supernet_of(self, other):
        pass
    def is_reserved(self):
        pass
    def is_link_local(self):
        pass
    def is_private(self):
        pass
    def is_global(self):
        pass
    def is_unspecified(self):
        pass
    def is_loopback(self):
        pass
    def _explode_shorthand_ip_string(self):
        pass
    def _make_netmask(cls, arg):
        pass
    def _ip_int_from_string(cls, ip_str):
        pass
    def _parse_octet(cls, octet_str):
        pass
    def _string_from_ip_int(cls, ip_int):
        pass
    def _reverse_pointer(self):
        pass
    def max_prefixlen(self):
        pass
    def version(self):
        pass
    def __init__(self, address):
        pass
    def packed(self):
        pass
    def is_reserved(self):
        pass
    def is_private(self):
        pass
    def is_global(self):
        pass
    def is_multicast(self):
        pass
    def is_unspecified(self):
        pass
    def is_loopback(self):
        pass
    def is_link_local(self):
        pass
    def __init__(self, address):
        pass
    def hostmask(self):
        pass
    def __str__(self):
        pass
    def __eq__(self, other):
        pass
    def __lt__(self, other):
        pass
    def __hash__(self):
        pass
    def ip(self):
        pass
    def with_prefixlen(self):
        pass
    def with_netmask(self):
        pass
    def with_hostmask(self):
        pass
    def __init__(self, address, strict=True):
        pass
    def is_global(self):
        pass
    def _make_netmask(cls, arg):
        pass
    def _ip_int_from_string(cls, ip_str):
        pass
    def _parse_hextet(cls, hextet_str):
        pass
    def _compress_hextets(cls, hextets):
        pass
    def _string_from_ip_int(cls, ip_int=None):
        pass
    def _explode_shorthand_ip_string(self):
        pass
    def _reverse_pointer(self):
        pass
    def _split_scope_id(ip_str):
        pass
    def max_prefixlen(self):
        pass
    def version(self):
        pass
    def __init__(self, address):
        pass
    def __str__(self):
        pass
    def __hash__(self):
        pass
    def __eq__(self, other):
        pass
    def scope_id(self):
        pass
    def packed(self):
        pass
    def is_multicast(self):
        pass
    def is_reserved(self):
        pass
    def is_link_local(self):
        pass
    def is_site_local(self):
        pass
    def is_private(self):
        pass
    def is_global(self):
        pass
    def is_unspecified(self):
        pass
    def is_loopback(self):
        pass
    def teredo(self):
        pass
    def sixtofour(self):
        pass
    def __init__(self, address):
        pass
    def hostmask(self):
        pass
    def __str__(self):
        pass
    def __eq__(self, other):
        pass
    def __lt__(self, other):
        pass
    def __hash__(self):
        pass
    def ip(self):
        pass
    def with_prefixlen(self):
        pass
    def with_netmask(self):
        pass
    def with_hostmask(self):
        pass
    def is_unspecified(self):
        pass
    def is_loopback(self):
        pass
    def __init__(self, address, strict=True):
        pass
    def hosts(self):
        pass
    def is_site_local(self):
        pass
"""# keyword.py #"""
"""# linecache.py #"""
def clearcache():
   pass
def getline(filename, lineno, module_globals=None):
   pass
def getlines(filename, module_globals=None):
   pass
def checkcache(filename=None):
   pass
def updatecache(filename, module_globals=None):
   pass
def lazycache(filename, module_globals):
   pass
"""# locale.py #"""
def _strcoll(a,b):
   pass
def _strxfrm(s):
   pass
    def localeconv():
        pass
    def setlocale(category, value=None):
        pass
def localeconv():
   pass
def _grouping_intervals(grouping):
   pass
def _group(s, monetary=False):
   pass
def _strip_padding(s, amount):
   pass
def _format(percent, value, grouping=False, monetary=False, *additional):
   pass
def format_string(f, val, grouping=False, monetary=False):
   pass
def format(percent, value, grouping=False, monetary=False, *additional):
   pass
def currency(val, symbol=True, grouping=False, international=False):
   pass
def str(val):
   pass
def delocalize(string):
   pass
def atof(string, func=float):
   pass
def atoi(string):
   pass
def _test():
   pass
def _replace_encoding(code, encoding):
   pass
def _append_modifier(code, modifier):
   pass
def normalize(localename):
   pass
def _parse_localename(localename):
   pass
def _build_localename(localetuple):
   pass
def getdefaultlocale(envvars=('LC_ALL', 'LC_CTYPE', 'LANG', 'LANGUAGE')):
   pass
def getlocale(category=LC_CTYPE):
   pass
def setlocale(category, locale=None):
   pass
def resetlocale(category=LC_ALL):
   pass
    def getpreferredencoding(do_setlocale = True):
        pass
            def getpreferredencoding(do_setlocale = True):
                        pass
            def getpreferredencoding(do_setlocale = True):
                        pass
        def getpreferredencoding(do_setlocale = True):
                pass
def _print_locale():
   pass
    def _init_categories(categories=categories):
        pass
"""# lzma.py #"""
class LZMAFile(_compression.BaseStream):
    def close(self):
        pass
    def closed(self):
        pass
    def fileno(self):
        pass
    def seekable(self):
        pass
    def readable(self):
        pass
    def writable(self):
        pass
    def peek(self, size=-1):
        pass
    def read(self, size=-1):
        pass
    def readline(self, size=-1):
        pass
    def write(self, data):
        pass
    def seek(self, offset, whence=io.SEEK_SET):
        pass
    def tell(self):
        pass
def compress(data, format=FORMAT_XZ, check=-1, preset=None, filters=None):
   pass
def decompress(data, format=FORMAT_AUTO, memlimit=None, filters=None):
   pass
"""# mailbox.py #"""
class Mailbox:
    def __init__(self, path, factory=None, create=True):
        pass
    def add(self, message):
        pass
    def remove(self, key):
        pass
    def __delitem__(self, key):
        pass
    def discard(self, key):
        pass
    def __setitem__(self, key, message):
        pass
    def get(self, key, default=None):
        pass
    def __getitem__(self, key):
        pass
    def get_message(self, key):
        pass
    def get_string(self, key):
        pass
    def get_bytes(self, key):
        pass
    def get_file(self, key):
        pass
    def iterkeys(self):
        pass
    def keys(self):
        pass
    def itervalues(self):
        pass
    def __iter__(self):
        pass
    def values(self):
        pass
    def iteritems(self):
        pass
    def items(self):
        pass
    def __contains__(self, key):
        pass
    def __len__(self):
        pass
    def clear(self):
        pass
    def pop(self, key, default=None):
        pass
    def popitem(self):
        pass
    def update(self, arg=None):
        pass
    def flush(self):
        pass
    def lock(self):
        pass
    def unlock(self):
        pass
    def close(self):
        pass
    def _string_to_bytes(self, message):
        pass
    def _dump_message(self, message, target, mangle_from_=False):
        pass
class Maildir(Mailbox):
    def __init__(self, dirname, factory=None, create=True):
        pass
    def add(self, message):
        pass
    def remove(self, key):
        pass
    def discard(self, key):
        pass
    def __setitem__(self, key, message):
        pass
    def get_message(self, key):
        pass
    def get_bytes(self, key):
        pass
    def get_file(self, key):
        pass
    def iterkeys(self):
        pass
    def __contains__(self, key):
        pass
    def __len__(self):
        pass
    def flush(self):
        pass
    def lock(self):
        pass
    def unlock(self):
        pass
    def close(self):
        pass
    def list_folders(self):
        pass
    def get_folder(self, folder):
        pass
    def add_folder(self, folder):
        pass
    def remove_folder(self, folder):
        pass
    def clean(self):
        pass
    def _create_tmp(self):
        pass
    def _refresh(self):
        pass
    def _lookup(self, key):
        pass
    def next(self):
        pass
class _singlefileMailbox(Mailbox):
    def __init__(self, path, factory=None, create=True):
        pass
    def add(self, message):
        pass
    def remove(self, key):
        pass
    def __setitem__(self, key, message):
        pass
    def iterkeys(self):
        pass
    def __contains__(self, key):
        pass
    def __len__(self):
        pass
    def lock(self):
        pass
    def unlock(self):
        pass
    def flush(self):
        pass
    def _pre_mailbox_hook(self, f):
        pass
    def _pre_message_hook(self, f):
        pass
    def _post_message_hook(self, f):
        pass
    def close(self):
        pass
    def _lookup(self, key=None):
        pass
    def _append_message(self, message):
        pass
class _mboxMMDF(_singlefileMailbox):
    def get_message(self, key):
        pass
    def get_string(self, key, from_=False):
        pass
    def get_bytes(self, key, from_=False):
        pass
    def get_file(self, key, from_=False):
        pass
    def _install_message(self, message):
        pass
class mbox(_mboxMMDF):
    def __init__(self, path, factory=None, create=True):
        pass
    def _post_message_hook(self, f):
        pass
    def _generate_toc(self):
        pass
class MMDF(_mboxMMDF):
    def __init__(self, path, factory=None, create=True):
        pass
    def _pre_message_hook(self, f):
        pass
    def _post_message_hook(self, f):
        pass
    def _generate_toc(self):
        pass
class MH(Mailbox):
    def __init__(self, path, factory=None, create=True):
        pass
    def add(self, message):
        pass
    def remove(self, key):
        pass
    def __setitem__(self, key, message):
        pass
    def get_message(self, key):
        pass
    def get_bytes(self, key):
        pass
    def get_file(self, key):
        pass
    def iterkeys(self):
        pass
    def __contains__(self, key):
        pass
    def __len__(self):
        pass
    def lock(self):
        pass
    def unlock(self):
        pass
    def flush(self):
        pass
    def close(self):
        pass
    def list_folders(self):
        pass
    def get_folder(self, folder):
        pass
    def add_folder(self, folder):
        pass
    def remove_folder(self, folder):
        pass
    def get_sequences(self):
        pass
    def set_sequences(self, sequences):
        pass
    def pack(self):
        pass
    def _dump_sequences(self, message, key):
        pass
class Babyl(_singlefileMailbox):
    def __init__(self, path, factory=None, create=True):
        pass
    def add(self, message):
        pass
    def remove(self, key):
        pass
    def __setitem__(self, key, message):
        pass
    def get_message(self, key):
        pass
    def get_bytes(self, key):
        pass
    def get_file(self, key):
        pass
    def get_labels(self):
        pass
    def _generate_toc(self):
        pass
    def _pre_mailbox_hook(self, f):
        pass
    def _pre_message_hook(self, f):
        pass
    def _post_message_hook(self, f):
        pass
    def _install_message(self, message):
        pass
class Message(email.message.Message):
    def __init__(self, message=None):
        pass
    def _become_message(self, message):
        pass
    def _explain_to(self, message):
        pass
class MaildirMessage(Message):
    def __init__(self, message=None):
        pass
    def get_subdir(self):
        pass
    def set_subdir(self, subdir):
        pass
    def get_flags(self):
        pass
    def set_flags(self, flags):
        pass
    def add_flag(self, flag):
        pass
    def remove_flag(self, flag):
        pass
    def get_date(self):
        pass
    def set_date(self, date):
        pass
    def get_info(self):
        pass
    def set_info(self, info):
        pass
    def _explain_to(self, message):
        pass
class _mboxMMDFMessage(Message):
    def __init__(self, message=None):
        pass
    def get_from(self):
        pass
    def set_from(self, from_, time_=None):
        pass
    def get_flags(self):
        pass
    def set_flags(self, flags):
        pass
    def add_flag(self, flag):
        pass
    def remove_flag(self, flag):
        pass
    def _explain_to(self, message):
        pass
class mboxMessage(_mboxMMDFMessage):
class MHMessage(Message):
    def __init__(self, message=None):
        pass
    def get_sequences(self):
        pass
    def set_sequences(self, sequences):
        pass
    def add_sequence(self, sequence):
        pass
    def remove_sequence(self, sequence):
        pass
    def _explain_to(self, message):
        pass
class BabylMessage(Message):
    def __init__(self, message=None):
        pass
    def get_labels(self):
        pass
    def set_labels(self, labels):
        pass
    def add_label(self, label):
        pass
    def remove_label(self, label):
        pass
    def get_visible(self):
        pass
    def set_visible(self, visible):
        pass
    def update_visible(self):
        pass
    def _explain_to(self, message):
        pass
class MMDFMessage(_mboxMMDFMessage):
class _ProxyFile:
    def __init__(self, f, pos=None):
        pass
    def read(self, size=None):
        pass
    def readline(self, size=None):
        pass
    def readlines(self, sizehint=None):
        pass
    def __iter__(self):
        pass
    def tell(self):
        pass
    def seek(self, offset, whence=0):
        pass
    def close(self):
        pass
    def _read(self, size, read_method):
        pass
    def __enter__(self):
        pass
    def __exit__(self, *exc):
        pass
    def readable(self):
        pass
    def writable(self):
        pass
    def seekable(self):
        pass
    def flush(self):
        pass
    def closed(self):
        pass
class _PartialFile(_ProxyFile):
    def __init__(self, f, start=None, stop=None):
        pass
    def tell(self):
        pass
    def seek(self, offset, whence=0):
        pass
    def _read(self, size, read_method):
        pass
    def close(self):
        pass
def _lock_file(f, dotlock=True):
   pass
def _unlock_file(f):
   pass
def _create_carefully(path):
   pass
def _create_temporary(path):
   pass
def _sync_flush(f):
   pass
def _sync_close(f):
   pass
class Error(Exception):
class NoSuchMailboxError(Error):
class NotEmptyError(Error):
class ExternalClashError(Error):
class FormatError(Error):
"""# mailcap.py #"""
def lineno_sort_key(entry):
   pass
def getcaps():
   pass
def listmailcapfiles():
   pass
def readmailcapfile(fp):
   pass
def _readmailcapfile(fp, lineno):
   pass
def parseline(line):
   pass
def parsefield(line, i, n):
   pass
def findmatch(caps, MIMEtype, key='view', filename="/dev/null", plist=[]):
   pass
def lookup(caps, MIMEtype, key=None):
   pass
def subst(field, MIMEtype, filename, plist=[]):
   pass
def findparam(name, plist):
   pass
def test():
   pass
def show(caps):
   pass
"""# mimetypes.py #"""
class MimeTypes:
    def __init__(self, filenames=(), strict=True):
        pass
    def add_type(self, type, ext, strict=True):
        pass
    def guess_type(self, url, strict=True):
        pass
    def guess_all_extensions(self, type, strict=True):
        pass
    def guess_extension(self, type, strict=True):
        pass
    def read(self, filename, strict=True):
        pass
    def readfp(self, fp, strict=True):
        pass
    def read_windows_registry(self, strict=True):
        pass
        def enum_types(mimedb):
                pass
def guess_type(url, strict=True):
   pass
def guess_all_extensions(type, strict=True):
   pass
def guess_extension(type, strict=True):
   pass
def add_type(type, ext, strict=True):
   pass
def init(files=None):
   pass
def read_mime_types(file):
   pass
def _default_mime_types():
   pass
def _main():
   pass
    def usage(code, msg=''):
        pass
"""# modulefinder.py #"""
def AddPackagePath(packagename, path):
   pass
def ReplacePackage(oldname, newname):
   pass
def _find_module(name, path=None):
   pass
class Module:
    def __init__(self, name, file=None, path=None):
        pass
    def __repr__(self):
        pass
class ModuleFinder:
    def __init__(self, path=None, debug=0, excludes=None, replace_paths=None):
        pass
    def msg(self, level, str, *args):
        pass
    def msgin(self, *args):
        pass
    def msgout(self, *args):
        pass
    def run_script(self, pathname):
        pass
    def load_file(self, pathname):
        pass
    def import_hook(self, name, caller=None, fromlist=None, level=-1):
        pass
    def determine_parent(self, caller, level=-1):
        pass
    def find_head_package(self, parent, name):
        pass
    def load_tail(self, q, tail):
        pass
    def ensure_fromlist(self, m, fromlist, recursive=0):
        pass
    def find_all_submodules(self, m):
        pass
    def import_module(self, partname, fqname, parent):
        pass
    def load_module(self, fqname, fp, pathname, file_info):
        pass
    def _add_badmodule(self, name, caller):
        pass
    def _safe_import_hook(self, name, caller, fromlist, level=-1):
        pass
    def scan_opcodes(self, co):
        pass
    def scan_code(self, co, m):
        pass
    def load_package(self, fqname, pathname):
        pass
    def add_module(self, fqname):
        pass
    def find_module(self, name, path, parent=None):
        pass
    def report(self):
        pass
    def any_missing(self):
        pass
    def any_missing_maybe(self):
        pass
    def replace_paths_in_code(self, co):
        pass
def test():
   pass
"""# netrc.py #"""
class NetrcParseError(Exception):
    def __init__(self, msg, filename=None, lineno=None):
        pass
    def __str__(self):
        pass
class netrc:
    def __init__(self, file=None):
        pass
    def _parse(self, file, fp, default_netrc):
        pass
    def authenticators(self, host):
        pass
    def __repr__(self):
        pass
"""# nntplib.py #"""
class NNTPError(Exception):
    def __init__(self, *args):
        pass
class NNTPReplyError(NNTPError):
class NNTPTemporaryError(NNTPError):
class NNTPPermanentError(NNTPError):
class NNTPProtocolError(NNTPError):
class NNTPDataError(NNTPError):
def decode_header(header_str):
   pass
def _parse_overview_fmt(lines):
   pass
def _parse_overview(lines, fmt, data_process_func=None):
   pass
def _parse_datetime(date_str, time_str=None):
   pass
def _unparse_datetime(dt, legacy=False):
   pass
    def _encrypt_on(sock, context, hostname):
        pass
class NNTP:
    def _base_init(self, readermode):
        pass
    def __enter__(self):
        pass
    def __exit__(self, *args):
        pass
    def _create_socket(self, timeout):
        pass
    def getwelcome(self):
        pass
    def getcapabilities(self):
        pass
    def set_debuglevel(self, level):
        pass
    def _putline(self, line):
        pass
    def _putcmd(self, line):
        pass
    def _getline(self, strip_crlf=True):
        pass
    def _getresp(self):
        pass
    def _getlongresp(self, file=None):
        pass
    def _shortcmd(self, line):
        pass
    def _longcmd(self, line, file=None):
        pass
    def _longcmdstring(self, line, file=None):
        pass
    def _getoverviewfmt(self):
        pass
    def _grouplist(self, lines):
        pass
    def capabilities(self):
        pass
    def newgroups(self, date, *, file=None):
        pass
    def newnews(self, group, date, *, file=None):
        pass
    def list(self, group_pattern=None, *, file=None):
        pass
    def _getdescriptions(self, group_pattern, return_all):
        pass
    def description(self, group):
        pass
    def descriptions(self, group_pattern):
        pass
    def group(self, name):
        pass
    def help(self, *, file=None):
        pass
    def _statparse(self, resp):
        pass
    def _statcmd(self, line):
        pass
    def stat(self, message_spec=None):
        pass
    def next(self):
        pass
    def last(self):
        pass
    def _artcmd(self, line, file=None):
        pass
    def head(self, message_spec=None, *, file=None):
        pass
    def body(self, message_spec=None, *, file=None):
        pass
    def article(self, message_spec=None, *, file=None):
        pass
    def slave(self):
        pass
    def xhdr(self, hdr, str, *, file=None):
        pass
        def remove_number(line):
                pass
    def xover(self, start, end, *, file=None):
        pass
    def over(self, message_spec, *, file=None):
        pass
    def date(self):
        pass
    def _post(self, command, f):
        pass
    def post(self, data):
        pass
    def ihave(self, message_id, data):
        pass
    def _close(self):
        pass
    def quit(self):
        pass
    def login(self, user=None, password=None, usenetrc=True):
        pass
    def _setreadermode(self):
        pass
        def starttls(self, context=None):
                pass
    class NNTP_SSL(NNTP):
        def _create_socket(self, timeout):
                pass
    def cut(s, lim):
        pass
"""# ntpath.py #"""
def _get_bothseps(path):
   pass
def normcase(s):
   pass
def isabs(s):
   pass
def join(path, *paths):
   pass
def splitdrive(p):
   pass
def split(p):
   pass
def splitext(p):
   pass
def basename(p):
   pass
def dirname(p):
   pass
def islink(path):
   pass
def lexists(path):
   pass
def ismount(path):
   pass
def expanduser(path):
   pass
def expandvars(path):
   pass
def normpath(path):
   pass
def _abspath_fallback(path):
   pass
    def abspath(path):
        pass
    def _readlink_deep(path):
        pass
    def _getfinalpathname_nonstrict(path):
        pass
    def realpath(path):
        pass
def relpath(path, start=None):
   pass
def commonpath(paths):
   pass
"""# nturl2path.py #"""
"""# numbers.py #"""
class Number(metaclass=ABCMeta):
class Complex(Number):
    def __complex__(self):
        pass
    def __bool__(self):
        pass
    def real(self):
        pass
    def imag(self):
        pass
    def __add__(self, other):
        pass
    def __radd__(self, other):
        pass
    def __neg__(self):
        pass
    def __pos__(self):
        pass
    def __sub__(self, other):
        pass
    def __rsub__(self, other):
        pass
    def __mul__(self, other):
        pass
    def __rmul__(self, other):
        pass
    def __truediv__(self, other):
        pass
    def __rtruediv__(self, other):
        pass
    def __pow__(self, exponent):
        pass
    def __rpow__(self, base):
        pass
    def __abs__(self):
        pass
    def conjugate(self):
        pass
    def __eq__(self, other):
        pass
class Real(Complex):
    def __float__(self):
        pass
    def __trunc__(self):
        pass
    def __floor__(self):
        pass
    def __ceil__(self):
        pass
    def __round__(self, ndigits=None):
        pass
    def __divmod__(self, other):
        pass
    def __rdivmod__(self, other):
        pass
    def __floordiv__(self, other):
        pass
    def __rfloordiv__(self, other):
        pass
    def __mod__(self, other):
        pass
    def __rmod__(self, other):
        pass
    def __lt__(self, other):
        pass
    def __le__(self, other):
        pass
    def __complex__(self):
        pass
    def real(self):
        pass
    def imag(self):
        pass
    def conjugate(self):
        pass
class Rational(Real):
    def numerator(self):
        pass
    def denominator(self):
        pass
    def __float__(self):
        pass
class Integral(Rational):
    def __int__(self):
        pass
    def __index__(self):
        pass
    def __pow__(self, exponent, modulus=None):
        pass
    def __lshift__(self, other):
        pass
    def __rlshift__(self, other):
        pass
    def __rshift__(self, other):
        pass
    def __rrshift__(self, other):
        pass
    def __and__(self, other):
        pass
    def __rand__(self, other):
        pass
    def __xor__(self, other):
        pass
    def __rxor__(self, other):
        pass
    def __or__(self, other):
        pass
    def __ror__(self, other):
        pass
    def __invert__(self):
        pass
    def __float__(self):
        pass
    def numerator(self):
        pass
    def denominator(self):
        pass
"""# opcode.py #"""
def def_op(name, op):
   pass
def name_op(name, op):
   pass
def jrel_op(name, op):
   pass
def jabs_op(name, op):
   pass
"""# operator.py #"""
def lt(a, b):
   pass
def le(a, b):
   pass
def eq(a, b):
   pass
def ne(a, b):
   pass
def ge(a, b):
   pass
def gt(a, b):
   pass
def not_(a):
   pass
def truth(a):
   pass
def is_(a, b):
   pass
def is_not(a, b):
   pass
def abs(a):
   pass
def add(a, b):
   pass
def and_(a, b):
   pass
def floordiv(a, b):
   pass
def index(a):
   pass
def inv(a):
   pass
def lshift(a, b):
   pass
def mod(a, b):
   pass
def mul(a, b):
   pass
def matmul(a, b):
   pass
def neg(a):
   pass
def or_(a, b):
   pass
def pos(a):
   pass
def pow(a, b):
   pass
def rshift(a, b):
   pass
def sub(a, b):
   pass
def truediv(a, b):
   pass
def xor(a, b):
   pass
def concat(a, b):
   pass
def contains(a, b):
   pass
def countOf(a, b):
   pass
def delitem(a, b):
   pass
def getitem(a, b):
   pass
def indexOf(a, b):
   pass
def setitem(a, b, c):
   pass
def length_hint(obj, default=0):
   pass
class attrgetter:
    def __init__(self, attr, *attrs):
        pass
            def func(obj):
                        pass
            def func(obj):
                        pass
    def __call__(self, obj):
        pass
    def __repr__(self):
        pass
    def __reduce__(self):
        pass
class itemgetter:
    def __init__(self, item, *items):
        pass
            def func(obj):
                        pass
            def func(obj):
                        pass
    def __call__(self, obj):
        pass
    def __repr__(self):
        pass
    def __reduce__(self):
        pass
class methodcaller:
    def __init__(self, name, /, *args, **kwargs):
        pass
    def __call__(self, obj):
        pass
    def __repr__(self):
        pass
    def __reduce__(self):
        pass
def iadd(a, b):
   pass
def iand(a, b):
   pass
def iconcat(a, b):
   pass
def ifloordiv(a, b):
   pass
def ilshift(a, b):
   pass
def imod(a, b):
   pass
def imul(a, b):
   pass
def imatmul(a, b):
   pass
def ior(a, b):
   pass
def ipow(a, b):
   pass
def irshift(a, b):
   pass
def isub(a, b):
   pass
def itruediv(a, b):
   pass
def ixor(a, b):
   pass
"""# optparse.py #"""
def _repr(self):
   pass
    def gettext(message):
        pass
    def ngettext(singular, plural, n):
        pass
class OptParseError (Exception):
    def __init__(self, msg):
        pass
    def __str__(self):
        pass
class OptionError (OptParseError):
    def __init__(self, msg, option):
        pass
    def __str__(self):
        pass
class OptionConflictError (OptionError):
class OptionValueError (OptParseError):
class BadOptionError (OptParseError):
    def __init__(self, opt_str):
        pass
    def __str__(self):
        pass
class AmbiguousOptionError (BadOptionError):
    def __init__(self, opt_str, possibilities):
        pass
    def __str__(self):
        pass
class HelpFormatter:
    def set_parser(self, parser):
        pass
    def set_short_opt_delimiter(self, delim):
        pass
    def set_long_opt_delimiter(self, delim):
        pass
    def indent(self):
        pass
    def dedent(self):
        pass
    def format_usage(self, usage):
        pass
    def format_heading(self, heading):
        pass
    def _format_text(self, text):
        pass
    def format_description(self, description):
        pass
    def format_epilog(self, epilog):
        pass
    def expand_default(self, option):
        pass
    def format_option(self, option):
        pass
    def store_option_strings(self, parser):
        pass
    def format_option_strings(self, option):
        pass
class IndentedHelpFormatter (HelpFormatter):
    def format_usage(self, usage):
        pass
    def format_heading(self, heading):
        pass
class TitledHelpFormatter (HelpFormatter):
    def format_usage(self, usage):
        pass
    def format_heading(self, heading):
        pass
def _parse_num(val, type):
   pass
def _parse_int(val):
   pass
def check_builtin(option, opt, value):
   pass
def check_choice(option, opt, value):
   pass
class Option:
    def __init__(self, *opts, **attrs):
        pass
    def _check_opt_strings(self, opts):
        pass
    def _set_opt_strings(self, opts):
        pass
    def _set_attrs(self, attrs):
        pass
    def _check_action(self):
        pass
    def _check_type(self):
        pass
    def _check_choice(self):
        pass
    def _check_dest(self):
        pass
    def _check_const(self):
        pass
    def _check_nargs(self):
        pass
    def _check_callback(self):
        pass
    def __str__(self):
        pass
    def takes_value(self):
        pass
    def get_opt_string(self):
        pass
    def check_value(self, opt, value):
        pass
    def convert_value(self, opt, value):
        pass
    def process(self, opt, value, values, parser):
        pass
    def take_action(self, action, dest, opt, value, values, parser):
        pass
class Values:
    def __init__(self, defaults=None):
        pass
    def __str__(self):
        pass
    def __eq__(self, other):
        pass
    def _update_careful(self, dict):
        pass
    def _update_loose(self, dict):
        pass
    def _update(self, dict, mode):
        pass
    def read_module(self, modname, mode="careful"):
        pass
    def read_file(self, filename, mode="careful"):
        pass
    def ensure_value(self, attr, value):
        pass
class OptionContainer:
    def __init__(self, option_class, conflict_handler, description):
        pass
    def _create_option_mappings(self):
        pass
    def _share_option_mappings(self, parser):
        pass
    def set_conflict_handler(self, handler):
        pass
    def set_description(self, description):
        pass
    def get_description(self):
        pass
    def destroy(self):
        pass
    def _check_conflict(self, option):
        pass
    def add_option(self, *args, **kwargs):
        pass
    def add_options(self, option_list):
        pass
    def get_option(self, opt_str):
        pass
    def has_option(self, opt_str):
        pass
    def remove_option(self, opt_str):
        pass
    def format_option_help(self, formatter):
        pass
    def format_description(self, formatter):
        pass
    def format_help(self, formatter):
        pass
class OptionGroup (OptionContainer):
    def __init__(self, parser, title, description=None):
        pass
    def _create_option_list(self):
        pass
    def set_title(self, title):
        pass
    def destroy(self):
        pass
    def format_help(self, formatter):
        pass
class OptionParser (OptionContainer):
    def destroy(self):
        pass
    def _create_option_list(self):
        pass
    def _add_help_option(self):
        pass
    def _add_version_option(self):
        pass
    def _populate_option_list(self, option_list, add_help=True):
        pass
    def _init_parsing_state(self):
        pass
    def set_usage(self, usage):
        pass
    def enable_interspersed_args(self):
        pass
    def disable_interspersed_args(self):
        pass
    def set_process_default_values(self, process):
        pass
    def set_default(self, dest, value):
        pass
    def set_defaults(self, **kwargs):
        pass
    def _get_all_options(self):
        pass
    def get_default_values(self):
        pass
    def add_option_group(self, *args, **kwargs):
        pass
    def get_option_group(self, opt_str):
        pass
    def _get_args(self, args):
        pass
    def parse_args(self, args=None, values=None):
        pass
    def check_values(self, values, args):
        pass
    def _process_args(self, largs, rargs, values):
        pass
    def _match_long_opt(self, opt):
        pass
    def _process_long_opt(self, rargs, values):
        pass
    def _process_short_opts(self, rargs, values):
        pass
    def get_prog_name(self):
        pass
    def expand_prog_name(self, s):
        pass
    def get_description(self):
        pass
    def exit(self, status=0, msg=None):
        pass
    def error(self, msg):
        pass
    def get_usage(self):
        pass
    def print_usage(self, file=None):
        pass
    def get_version(self):
        pass
    def print_version(self, file=None):
        pass
    def format_option_help(self, formatter=None):
        pass
    def format_epilog(self, formatter):
        pass
    def format_help(self, formatter=None):
        pass
    def print_help(self, file=None):
        pass
def _match_abbrev(s, wordmap):
   pass
"""# os.py #"""
def _exists(name):
   pass
def _get_exports_list(module):
   pass
    def _add(str, fn):
        pass
def makedirs(name, mode=0o777, exist_ok=False):
   pass
def removedirs(name):
   pass
def renames(old, new):
   pass
def walk(top, topdown=True, onerror=None, followlinks=False):
   pass
def _walk(top, topdown, onerror, followlinks):
   pass
    def fwalk(top=".", topdown=True, onerror=None, *, follow_symlinks=False, dir_fd=None):
        pass
    def _fwalk(topfd, toppath, isbytes, topdown, onerror, follow_symlinks):
        pass
def execl(file, *args):
   pass
def execle(file, *args):
   pass
def execlp(file, *args):
   pass
def execlpe(file, *args):
   pass
def execvp(file, args):
   pass
def execvpe(file, args, env):
   pass
def _execvpe(file, args, env=None):
   pass
def get_exec_path(env=None):
   pass
class _Environ(MutableMapping):
    def __init__(self, data, encodekey, decodekey, encodevalue, decodevalue):
        pass
    def __getitem__(self, key):
        pass
    def __setitem__(self, key, value):
        pass
    def __delitem__(self, key):
        pass
    def __iter__(self):
        pass
    def __len__(self):
        pass
    def __repr__(self):
        pass
    def copy(self):
        pass
    def setdefault(self, key, value):
        pass
    def __ior__(self, other):
        pass
    def __or__(self, other):
        pass
    def __ror__(self, other):
        pass
def _createenviron():
   pass
        def check_str(value):
                pass
        def encodekey(key):
                pass
        def encode(value):
                pass
        def decode(value):
                pass
def getenv(key, default=None):
   pass
    def _check_bytes(value):
        pass
    def getenvb(key, default=None):
        pass
def _fscodec():
   pass
    def fsencode(filename):
        pass
    def fsdecode(filename):
        pass
    def _spawnvef(mode, file, args, env, func):
        pass
    def spawnv(mode, file, args):
        pass
    def spawnve(mode, file, args, env):
        pass
    def spawnvp(mode, file, args):
        pass
    def spawnvpe(mode, file, args, env):
        pass
    def spawnl(mode, file, *args):
        pass
    def spawnle(mode, file, *args):
        pass
    def spawnlp(mode, file, *args):
        pass
    def spawnlpe(mode, file, *args):
        pass
def popen(cmd, mode="r", buffering=-1):
   pass
class _wrap_close:
    def __init__(self, stream, proc):
        pass
    def close(self):
        pass
    def __enter__(self):
        pass
    def __exit__(self, *args):
        pass
    def __getattr__(self, name):
        pass
    def __iter__(self):
        pass
def fdopen(fd, *args, **kwargs):
   pass
def _fspath(path):
   pass
class PathLike(abc.ABC):
    def __fspath__(self):
        pass
    def __subclasshook__(cls, subclass):
        pass
    class _AddedDllDirectory:
        def __init__(self, path, cookie, remove_dll_directory):
                pass
        def close(self):
                pass
        def __enter__(self):
                pass
        def __exit__(self, *args):
                pass
        def __repr__(self):
                pass
    def add_dll_directory(path):
        pass
"""# pathlib.py #"""
def _ignore_error(exception):
   pass
def _is_wildcard_pattern(pat):
   pass
class _Flavour(object):
    def __init__(self):
        pass
    def parse_parts(self, parts):
        pass
    def join_parsed_parts(self, drv, root, parts, drv2, root2, parts2):
        pass
class _WindowsFlavour(_Flavour):
    def splitroot(self, part, sep=sep):
        pass
    def casefold(self, s):
        pass
    def casefold_parts(self, parts):
        pass
    def compile_pattern(self, pattern):
        pass
    def resolve(self, path, strict=False):
        pass
    def _split_extended_path(self, s, ext_prefix=ext_namespace_prefix):
        pass
    def _ext_to_normal(self, s):
        pass
    def is_reserved(self, parts):
        pass
    def make_uri(self, path):
        pass
    def gethomedir(self, username):
        pass
class _PosixFlavour(_Flavour):
    def splitroot(self, part, sep=sep):
        pass
    def casefold(self, s):
        pass
    def casefold_parts(self, parts):
        pass
    def compile_pattern(self, pattern):
        pass
    def resolve(self, path, strict=False):
        pass
        def _resolve(path, rest):
                pass
    def is_reserved(self, parts):
        pass
    def make_uri(self, path):
        pass
    def gethomedir(self, username):
        pass
class _Accessor:
class _NormalAccessor(_Accessor):
        def lchmod(self, pathobj, mode):
                pass
        def link_to(self, target):
                pass
            def symlink(a, b, target_is_directory):
                        pass
        def symlink(a, b, target_is_directory):
                pass
    def readlink(self, path):
        pass
    def owner(self, path):
        pass
    def group(self, path):
        pass
def _make_selector(pattern_parts, flavour):
   pass
class _Selector:
    def __init__(self, child_parts, flavour):
        pass
    def select_from(self, parent_path):
        pass
class _TerminatingSelector:
    def _select_from(self, parent_path, is_dir, exists, scandir):
        pass
class _PreciseSelector(_Selector):
    def __init__(self, name, child_parts, flavour):
        pass
    def _select_from(self, parent_path, is_dir, exists, scandir):
        pass
class _WildcardSelector(_Selector):
    def __init__(self, pat, child_parts, flavour):
        pass
    def _select_from(self, parent_path, is_dir, exists, scandir):
        pass
class _RecursiveWildcardSelector(_Selector):
    def __init__(self, pat, child_parts, flavour):
        pass
    def _iterate_directories(self, parent_path, is_dir, scandir):
        pass
    def _select_from(self, parent_path, is_dir, exists, scandir):
        pass
class _PathParents(Sequence):
    def __init__(self, path):
        pass
    def __len__(self):
        pass
    def __getitem__(self, idx):
        pass
    def __repr__(self):
        pass
class PurePath(object):
    def __new__(cls, *args):
        pass
    def __reduce__(self):
        pass
    def _parse_args(cls, args):
        pass
    def _from_parts(cls, args, init=True):
        pass
    def _from_parsed_parts(cls, drv, root, parts, init=True):
        pass
    def _format_parsed_parts(cls, drv, root, parts):
        pass
    def _init(self):
        pass
    def _make_child(self, args):
        pass
    def __str__(self):
        pass
    def __fspath__(self):
        pass
    def as_posix(self):
        pass
    def __bytes__(self):
        pass
    def __repr__(self):
        pass
    def as_uri(self):
        pass
    def _cparts(self):
        pass
    def __eq__(self, other):
        pass
    def __hash__(self):
        pass
    def __lt__(self, other):
        pass
    def __le__(self, other):
        pass
    def __gt__(self, other):
        pass
    def __ge__(self, other):
        pass
    def __class_getitem__(cls, type):
        pass
    def anchor(self):
        pass
    def name(self):
        pass
    def suffix(self):
        pass
    def suffixes(self):
        pass
    def stem(self):
        pass
    def with_name(self, name):
        pass
    def with_stem(self, stem):
        pass
    def with_suffix(self, suffix):
        pass
    def relative_to(self, *other):
        pass
    def is_relative_to(self, *other):
        pass
    def parts(self):
        pass
    def joinpath(self, *args):
        pass
    def __truediv__(self, key):
        pass
    def __rtruediv__(self, key):
        pass
    def parent(self):
        pass
    def parents(self):
        pass
    def is_absolute(self):
        pass
    def is_reserved(self):
        pass
    def match(self, path_pattern):
        pass
class PurePosixPath(PurePath):
class PureWindowsPath(PurePath):
class Path(PurePath):
    def __new__(cls, *args, **kwargs):
        pass
    def _make_child_relpath(self, part):
        pass
    def __enter__(self):
        pass
    def __exit__(self, t, v, tb):
        pass
    def _opener(self, name, flags, mode=0o666):
        pass
    def _raw_open(self, flags, mode=0o777):
        pass
    def cwd(cls):
        pass
    def home(cls):
        pass
    def samefile(self, other_path):
        pass
    def iterdir(self):
        pass
    def glob(self, pattern):
        pass
    def rglob(self, pattern):
        pass
    def absolute(self):
        pass
    def resolve(self, strict=False):
        pass
    def stat(self):
        pass
    def owner(self):
        pass
    def group(self):
        pass
    def read_bytes(self):
        pass
    def read_text(self, encoding=None, errors=None):
        pass
    def write_bytes(self, data):
        pass
    def write_text(self, data, encoding=None, errors=None):
        pass
    def readlink(self):
        pass
    def touch(self, mode=0o666, exist_ok=True):
        pass
    def mkdir(self, mode=0o777, parents=False, exist_ok=False):
        pass
    def chmod(self, mode):
        pass
    def lchmod(self, mode):
        pass
    def unlink(self, missing_ok=False):
        pass
    def rmdir(self):
        pass
    def lstat(self):
        pass
    def link_to(self, target):
        pass
    def rename(self, target):
        pass
    def replace(self, target):
        pass
    def symlink_to(self, target, target_is_directory=False):
        pass
    def exists(self):
        pass
    def is_dir(self):
        pass
    def is_file(self):
        pass
    def is_mount(self):
        pass
    def is_symlink(self):
        pass
    def is_block_device(self):
        pass
    def is_char_device(self):
        pass
    def is_fifo(self):
        pass
    def is_socket(self):
        pass
    def expanduser(self):
        pass
class PosixPath(Path, PurePosixPath):
class WindowsPath(Path, PureWindowsPath):
    def is_mount(self):
        pass
"""# pdb.py #"""
class Restart(Exception):
def find_function(funcname, filename):
   pass
def getsourcelines(obj):
   pass
class _rstr(str):
    def __repr__(self):
        pass
class Pdb(bdb.Bdb, cmd.Cmd):
    def sigint_handler(self, signum, frame):
        pass
    def reset(self):
        pass
    def forget(self):
        pass
    def setup(self, f, tb):
        pass
    def execRcLines(self):
        pass
    def user_call(self, frame, argument_list):
        pass
    def user_line(self, frame):
        pass
    def bp_commands(self, frame):
        pass
    def user_return(self, frame, return_value):
        pass
    def user_exception(self, frame, exc_info):
        pass
    def _cmdloop(self):
        pass
    def preloop(self):
        pass
    def interaction(self, frame, traceback):
        pass
    def displayhook(self, obj):
        pass
    def default(self, line):
        pass
    def precmd(self, line):
        pass
    def onecmd(self, line):
        pass
    def handle_command_def(self, line):
        pass
    def message(self, msg):
        pass
    def error(self, msg):
        pass
    def _complete_location(self, text, line, begidx, endidx):
        pass
    def _complete_bpnumber(self, text, line, begidx, endidx):
        pass
    def _complete_expression(self, text, line, begidx, endidx):
        pass
    def do_commands(self, arg):
        pass
    def do_break(self, arg, temporary = 0):
        pass
    def defaultFile(self):
        pass
    def do_tbreak(self, arg):
        pass
    def lineinfo(self, identifier):
        pass
    def checkline(self, filename, lineno):
        pass
    def do_enable(self, arg):
        pass
    def do_disable(self, arg):
        pass
    def do_condition(self, arg):
        pass
    def do_ignore(self, arg):
        pass
    def do_clear(self, arg):
        pass
    def do_where(self, arg):
        pass
    def _select_frame(self, number):
        pass
    def do_up(self, arg):
        pass
    def do_down(self, arg):
        pass
    def do_until(self, arg):
        pass
    def do_step(self, arg):
        pass
    def do_next(self, arg):
        pass
    def do_run(self, arg):
        pass
    def do_return(self, arg):
        pass
    def do_continue(self, arg):
        pass
    def do_jump(self, arg):
        pass
    def do_debug(self, arg):
        pass
    def do_quit(self, arg):
        pass
    def do_EOF(self, arg):
        pass
    def do_args(self, arg):
        pass
    def do_retval(self, arg):
        pass
    def _getval(self, arg):
        pass
    def _getval_except(self, arg, frame=None):
        pass
    def do_p(self, arg):
        pass
    def do_pp(self, arg):
        pass
    def do_list(self, arg):
        pass
    def do_longlist(self, arg):
        pass
    def do_source(self, arg):
        pass
    def _print_lines(self, lines, start, breaks=(), frame=None):
        pass
    def do_whatis(self, arg):
        pass
    def do_display(self, arg):
        pass
    def do_undisplay(self, arg):
        pass
    def complete_undisplay(self, text, line, begidx, endidx):
        pass
    def do_interact(self, arg):
        pass
    def do_alias(self, arg):
        pass
    def do_unalias(self, arg):
        pass
    def complete_unalias(self, text, line, begidx, endidx):
        pass
    def print_stack_trace(self):
        pass
    def print_stack_entry(self, frame_lineno, prompt_prefix=line_prefix):
        pass
    def do_help(self, arg):
        pass
    def help_exec(self):
        pass
    def help_pdb(self):
        pass
    def lookupmodule(self, filename):
        pass
    def _runmodule(self, module_name):
        pass
    def _runscript(self, filename):
        pass
def run(statement, globals=None, locals=None):
   pass
def runeval(expression, globals=None, locals=None):
   pass
def runctx(statement, globals, locals):
   pass
def runcall(*args, **kwds):
   pass
def set_trace(*, header=None):
   pass
def post_mortem(t=None):
   pass
def pm():
   pass
def test():
   pass
def help():
   pass
def main():
   pass
"""# pickle.py #"""
class PickleError(Exception):
class PicklingError(PickleError):
class UnpicklingError(PickleError):
class _Stop(Exception):
    def __init__(self, value):
        pass
class _Framer:
    def __init__(self, file_write):
        pass
    def start_framing(self):
        pass
    def end_framing(self):
        pass
    def commit_frame(self, force=False):
        pass
    def write(self, data):
        pass
    def write_large_bytes(self, header, payload):
        pass
class _Unframer:
    def __init__(self, file_read, file_readline, file_tell=None):
        pass
    def readinto(self, buf):
        pass
    def read(self, n):
        pass
    def readline(self):
        pass
    def load_frame(self, frame_size):
        pass
def _getattribute(obj, name):
   pass
def whichmodule(obj, name):
   pass
def encode_long(x):
   pass
def decode_long(data):
   pass
class _Pickler:
    def clear_memo(self):
        pass
    def dump(self, obj):
        pass
    def memoize(self, obj):
        pass
    def put(self, idx):
        pass
    def get(self, i):
        pass
    def save(self, obj, save_persistent_id=True):
        pass
    def persistent_id(self, obj):
        pass
    def save_pers(self, pid):
        pass
    def save_none(self, obj):
        pass
    def save_bool(self, obj):
        pass
    def save_long(self, obj):
        pass
    def save_float(self, obj):
        pass
    def save_bytes(self, obj):
        pass
    def save_bytearray(self, obj):
        pass
        def save_picklebuffer(self, obj):
                pass
    def save_str(self, obj):
        pass
    def save_tuple(self, obj):
        pass
    def save_list(self, obj):
        pass
    def _batch_appends(self, items):
        pass
    def save_dict(self, obj):
        pass
    def _batch_setitems(self, items):
        pass
    def save_set(self, obj):
        pass
    def save_frozenset(self, obj):
        pass
    def save_global(self, obj, name=None):
        pass
    def save_type(self, obj):
        pass
class _Unpickler:
    def load(self):
        pass
    def pop_mark(self):
        pass
    def persistent_load(self, pid):
        pass
    def load_proto(self):
        pass
    def load_frame(self):
        pass
    def load_persid(self):
        pass
    def load_binpersid(self):
        pass
    def load_none(self):
        pass
    def load_false(self):
        pass
    def load_true(self):
        pass
    def load_int(self):
        pass
    def load_binint(self):
        pass
    def load_long(self):
        pass
    def load_float(self):
        pass
    def load_binfloat(self):
        pass
    def _decode_string(self, value):
        pass
    def load_string(self):
        pass
    def load_binstring(self):
        pass
    def load_binbytes(self):
        pass
    def load_unicode(self):
        pass
    def load_binunicode(self):
        pass
    def load_next_buffer(self):
        pass
    def load_readonly_buffer(self):
        pass
    def load_short_binstring(self):
        pass
    def load_short_binbytes(self):
        pass
    def load_short_binunicode(self):
        pass
    def load_tuple(self):
        pass
    def load_empty_tuple(self):
        pass
    def load_empty_list(self):
        pass
    def load_empty_dictionary(self):
        pass
    def load_empty_set(self):
        pass
    def load_frozenset(self):
        pass
    def load_list(self):
        pass
    def load_dict(self):
        pass
    def _instantiate(self, klass, args):
        pass
    def load_inst(self):
        pass
    def load_obj(self):
        pass
    def load_newobj(self):
        pass
    def load_newobj_ex(self):
        pass
    def load_global(self):
        pass
    def load_stack_global(self):
        pass
    def get_extension(self, code):
        pass
    def find_class(self, module, name):
        pass
    def load_reduce(self):
        pass
    def load_pop(self):
        pass
    def load_pop_mark(self):
        pass
    def load_dup(self):
        pass
    def load_get(self):
        pass
    def load_binget(self):
        pass
    def load_long_binget(self):
        pass
    def load_put(self):
        pass
    def load_binput(self):
        pass
    def load_long_binput(self):
        pass
    def load_memoize(self):
        pass
    def load_append(self):
        pass
    def load_appends(self):
        pass
    def load_setitem(self):
        pass
    def load_setitems(self):
        pass
    def load_additems(self):
        pass
    def load_build(self):
        pass
    def load_mark(self):
        pass
    def load_stop(self):
        pass
def _dump(obj, file, protocol=None, *, fix_imports=True, buffer_callback=None):
   pass
def _dumps(obj, protocol=None, *, fix_imports=True, buffer_callback=None):
   pass
def _test():
   pass
"""# pickletools.py #"""
class ArgumentDescriptor(object):
    def __init__(self, name, n, reader, doc):
        pass
def read_stringnl(f, decode=True, stripquotes=True):
   pass
def read_stringnl_noescape(f):
   pass
def read_stringnl_noescape_pair(f):
   pass
def read_unicodestringnl(f):
   pass
def read_decimalnl_short(f):
   pass
def read_decimalnl_long(f):
   pass
def read_floatnl(f):
   pass
class StackObject(object):
    def __init__(self, name, obtype, doc):
        pass
    def __repr__(self):
        pass
class OpcodeInfo(object):
def assure_pickle_consistency(verbose=False):
   pass
def _genops(data, yield_end_pos=False):
   pass
def genops(pickle):
   pass
def optimize(p):
   pass
def dis(pickle, out=None, memo=None, indentlevel=4, annotate=0):
   pass
class _Example:
    def __init__(self, value):
        pass
def _test():
   pass
"""# pipes.py #"""
class Template:
    def __init__(self):
        pass
    def __repr__(self):
        pass
    def reset(self):
        pass
    def clone(self):
        pass
    def debug(self, flag):
        pass
    def append(self, cmd, kind):
        pass
    def prepend(self, cmd, kind):
        pass
    def open(self, file, rw):
        pass
    def open_r(self, file):
        pass
    def open_w(self, file):
        pass
    def copy(self, infile, outfile):
        pass
    def makepipeline(self, infile, outfile):
        pass
def makepipeline(infile, steps, outfile):
   pass
"""# pkgutil.py #"""
def _get_spec(finder, name):
   pass
def read_code(stream):
   pass
def walk_packages(path=None, prefix='', onerror=None):
   pass
    def seen(p, m={}):
        pass
def iter_modules(path=None, prefix=''):
   pass
def iter_importer_modules(importer, prefix=''):
   pass
def _iter_file_finder_modules(importer, prefix=''):
   pass
def _import_imp():
   pass
class ImpImporter:
    def __init__(self, path=None):
        pass
    def find_module(self, fullname, path=None):
        pass
    def iter_modules(self, prefix=''):
        pass
class ImpLoader:
    def __init__(self, fullname, file, filename, etc):
        pass
    def load_module(self, fullname):
        pass
    def get_data(self, pathname):
        pass
    def _reopen(self):
        pass
    def _fix_name(self, fullname):
        pass
    def is_package(self, fullname):
        pass
    def get_code(self, fullname=None):
        pass
    def get_source(self, fullname=None):
        pass
    def _get_delegate(self):
        pass
    def get_filename(self, fullname=None):
        pass
    def iter_zipimport_modules(importer, prefix=''):
        pass
def get_importer(path_item):
   pass
def iter_importers(fullname=""):
   pass
def get_loader(module_or_name):
   pass
def find_loader(fullname):
   pass
def extend_path(path, name):
   pass
def get_data(package, resource):
   pass
def resolve_name(name):
   pass
"""# platform.py #"""
def _comparable_version(version):
   pass
def libc_ver(executable=None, lib='', version='', chunksize=16384):
   pass
def _norm_version(version, build=''):
   pass
def _mac_ver_xml():
   pass
def mac_ver(release='', versioninfo=('', '', ''), machine=''):
   pass
def _java_getprop(name, default):
   pass
def java_ver(release='', vendor='', vminfo=('', '', ''), osinfo=('', '', '')):
   pass
def system_alias(system, release, version):
   pass
def _platform(*args):
   pass
def _node(default=''):
   pass
def _follow_symlinks(filepath):
   pass
def _syscmd_file(target, default=''):
   pass
def architecture(executable=sys.executable, bits='', linkage=''):
   pass
class _Processor:
    def get(cls):
        pass
    def get_OpenVMS():
        pass
    def from_subprocess():
        pass
def _unknown_as_blank(val):
   pass
    def processor(self):
        pass
    def __iter__(self):
        pass
    def __getitem__(self, key):
        pass
    def __len__(self):
        pass
def uname():
   pass
def system():
   pass
def node():
   pass
def release():
   pass
def version():
   pass
def machine():
   pass
def processor():
   pass
def _sys_version(sys_version=None):
   pass
def python_implementation():
   pass
def python_version():
   pass
def python_version_tuple():
   pass
def python_branch():
   pass
def python_revision():
   pass
def python_build():
   pass
def python_compiler():
   pass
def platform(aliased=0, terse=0):
   pass
"""# plistlib.py #"""
class UID:
    def __init__(self, data):
        pass
    def __index__(self):
        pass
    def __repr__(self):
        pass
    def __reduce__(self):
        pass
    def __eq__(self, other):
        pass
    def __hash__(self):
        pass
def _date_from_string(s):
   pass
def _date_to_string(d):
   pass
def _escape(text):
   pass
class _PlistParser:
    def __init__(self, dict_type):
        pass
    def parse(self, fileobj):
        pass
    def handle_entity_decl(self, entity_name, is_parameter_entity, value, base, system_id, public_id, notation_name):
        pass
    def handle_begin_element(self, element, attrs):
        pass
    def handle_end_element(self, element):
        pass
    def handle_data(self, data):
        pass
    def add_object(self, value):
        pass
    def get_data(self):
        pass
    def begin_dict(self, attrs):
        pass
    def end_dict(self):
        pass
    def end_key(self):
        pass
    def begin_array(self, attrs):
        pass
    def end_array(self):
        pass
    def end_true(self):
        pass
    def end_false(self):
        pass
    def end_integer(self):
        pass
    def end_real(self):
        pass
    def end_string(self):
        pass
    def end_data(self):
        pass
    def end_date(self):
        pass
class _DumbXMLWriter:
    def __init__(self, file, indent_level=0, indent="\t"):
        pass
    def begin_element(self, element):
        pass
    def end_element(self, element):
        pass
    def simple_element(self, element, value=None):
        pass
    def writeln(self, line):
        pass
class _PlistWriter(_DumbXMLWriter):
    def write(self, value):
        pass
    def write_value(self, value):
        pass
    def write_bytes(self, data):
        pass
    def write_dict(self, d):
        pass
    def write_array(self, array):
        pass
def _is_fmt_xml(header):
   pass
class InvalidFileException (ValueError):
    def __init__(self, message="Invalid file"):
        pass
class _BinaryPlistParser:
    def __init__(self, dict_type):
        pass
    def parse(self, fp):
        pass
    def _get_size(self, tokenL):
        pass
    def _read_ints(self, n, size):
        pass
    def _read_refs(self, n):
        pass
    def _read_object(self, ref):
        pass
def _count_to_size(count):
   pass
class _BinaryPlistWriter (object):
    def __init__(self, fp, sort_keys, skipkeys):
        pass
    def write(self, value):
        pass
    def _flatten(self, value):
        pass
    def _getrefnum(self, value):
        pass
    def _write_size(self, token, size):
        pass
    def _write_object(self, value):
        pass
def _is_fmt_binary(header):
   pass
def load(fp, *, fmt=None, dict_type=dict):
   pass
def loads(value, *, fmt=None, dict_type=dict):
   pass
def dump(value, fp, *, fmt=FMT_XML, sort_keys=True, skipkeys=False):
   pass
def dumps(value, *, fmt=FMT_XML, skipkeys=False, sort_keys=True):
   pass
"""# poplib.py #"""
class error_proto(Exception): pass
    def _create_socket(self, timeout):
        pass
    def _putline(self, line):
        pass
    def _putcmd(self, line):
        pass
    def _getline(self):
        pass
    def _getresp(self):
        pass
    def _getlongresp(self):
        pass
    def _shortcmd(self, line):
        pass
    def _longcmd(self, line):
        pass
    def getwelcome(self):
        pass
    def set_debuglevel(self, level):
        pass
    def user(self, user):
        pass
    def pass_(self, pswd):
        pass
    def stat(self):
        pass
    def list(self, which=None):
        pass
    def retr(self, which):
        pass
    def dele(self, which):
        pass
    def noop(self):
        pass
    def rset(self):
        pass
    def quit(self):
        pass
    def close(self):
        pass
    def rpop(self, user):
        pass
    def apop(self, user, password):
        pass
    def top(self, which, howmuch):
        pass
    def uidl(self, which=None):
        pass
    def capa(self):
        pass
        def _parsecap(line):
                pass
    def stls(self, context=None):
        pass
        def _create_socket(self, timeout):
                pass
        def stls(self, keyfile=None, certfile=None, context=None):
                pass
"""# posixpath.py #"""
def _get_sep(path):
   pass
def normcase(s):
   pass
def isabs(s):
   pass
def join(a, *p):
   pass
def split(p):
   pass
def splitext(p):
   pass
def splitdrive(p):
   pass
def basename(p):
   pass
def dirname(p):
   pass
def islink(path):
   pass
def lexists(path):
   pass
def ismount(path):
   pass
def expanduser(path):
   pass
def expandvars(path):
   pass
def normpath(path):
   pass
def abspath(path):
   pass
def realpath(filename):
   pass
def _joinrealpath(path, rest, seen):
   pass
def relpath(path, start=None):
   pass
def commonpath(paths):
   pass
"""# pprint.py #"""
def pp(object, *args, sort_dicts=False, **kwargs):
   pass
def saferepr(object):
   pass
def isreadable(object):
   pass
def isrecursive(object):
   pass
class _safe_key:
    def __init__(self, obj):
        pass
    def __lt__(self, other):
        pass
def _safe_tuple(t):
   pass
class PrettyPrinter:
    def pprint(self, object):
        pass
    def pformat(self, object):
        pass
    def isrecursive(self, object):
        pass
    def isreadable(self, object):
        pass
    def _format(self, object, stream, indent, allowance, context, level):
        pass
    def _pprint_dict(self, object, stream, indent, allowance, context, level):
        pass
    def _pprint_ordered_dict(self, object, stream, indent, allowance, context, level):
        pass
    def _pprint_list(self, object, stream, indent, allowance, context, level):
        pass
    def _pprint_tuple(self, object, stream, indent, allowance, context, level):
        pass
    def _pprint_set(self, object, stream, indent, allowance, context, level):
        pass
    def _pprint_str(self, object, stream, indent, allowance, context, level):
        pass
    def _pprint_bytes(self, object, stream, indent, allowance, context, level):
        pass
    def _pprint_bytearray(self, object, stream, indent, allowance, context, level):
        pass
    def _pprint_mappingproxy(self, object, stream, indent, allowance, context, level):
        pass
    def _pprint_simplenamespace(self, object, stream, indent, allowance, context, level):
        pass
    def _format_items(self, items, stream, indent, allowance, context, level):
        pass
    def _repr(self, object, context, level):
        pass
    def format(self, object, context, maxlevels, level):
        pass
    def _pprint_default_dict(self, object, stream, indent, allowance, context, level):
        pass
    def _pprint_counter(self, object, stream, indent, allowance, context, level):
        pass
    def _pprint_chain_map(self, object, stream, indent, allowance, context, level):
        pass
    def _pprint_deque(self, object, stream, indent, allowance, context, level):
        pass
    def _pprint_user_dict(self, object, stream, indent, allowance, context, level):
        pass
    def _pprint_user_list(self, object, stream, indent, allowance, context, level):
        pass
    def _pprint_user_string(self, object, stream, indent, allowance, context, level):
        pass
def _safe_repr(object, context, maxlevels, level, sort_dicts):
   pass
def _recursion(object):
   pass
def _perfcheck(object=None):
   pass
def _wrap_bytes_repr(object, width, allowance):
   pass
"""# profile.py #"""
class _Utils:
    def __init__(self, profiler):
        pass
    def run(self, statement, filename, sort):
        pass
    def runctx(self, statement, globals, locals, filename, sort):
        pass
    def _show(self, prof, filename, sort):
        pass
def run(statement, filename=None, sort=-1):
   pass
def runctx(statement, globals, locals, filename=None, sort=-1):
   pass
class Profile:
    def __init__(self, timer=None, bias=None):
        pass
                def get_time_timer(timer=timer, sum=sum):
                                pass
    def trace_dispatch(self, frame, event, arg):
        pass
    def trace_dispatch_i(self, frame, event, arg):
        pass
    def trace_dispatch_mac(self, frame, event, arg):
        pass
    def trace_dispatch_l(self, frame, event, arg):
        pass
    def trace_dispatch_exception(self, frame, t):
        pass
    def trace_dispatch_call(self, frame, t):
        pass
    def trace_dispatch_c_call (self, frame, t):
        pass
    def trace_dispatch_return(self, frame, t):
        pass
    def set_cmd(self, cmd):
        pass
    class fake_code:
        def __init__(self, filename, line, name):
                pass
        def __repr__(self):
                pass
    class fake_frame:
        def __init__(self, code, prior):
                pass
    def simulate_call(self, name):
        pass
    def simulate_cmd_complete(self):
        pass
    def print_stats(self, sort=-1):
        pass
    def dump_stats(self, file):
        pass
    def create_stats(self):
        pass
    def snapshot_stats(self):
        pass
    def run(self, cmd):
        pass
    def runctx(self, cmd, globals, locals):
        pass
    def runcall(self, func, /, *args, **kw):
        pass
    def calibrate(self, m, verbose=0):
        pass
    def _calibrate_inner(self, m, verbose):
        pass
        def f(m, f1=f1):
                pass
def main():
   pass
"""# pstats.py #"""
class SortKey(str, Enum):
    def __new__(cls, *values):
        pass
class FunctionProfile:
class StatsProfile:
class Stats:
    def __init__(self, *args, stream=None):
        pass
    def init(self, arg):
        pass
    def load_stats(self, arg):
        pass
    def get_top_level_stats(self):
        pass
    def add(self, *arg_list):
        pass
    def dump_stats(self, filename):
        pass
    def get_sort_arg_defs(self):
        pass
    def sort_stats(self, *field):
        pass
    def reverse_order(self):
        pass
    def strip_dirs(self):
        pass
    def calc_callees(self):
        pass
    def eval_print_amount(self, sel, list, msg):
        pass
    def get_stats_profile(self):
        pass
    def get_print_list(self, sel_list):
        pass
    def print_stats(self, *amount):
        pass
    def print_callees(self, *amount):
        pass
    def print_callers(self, *amount):
        pass
    def print_call_heading(self, name_size, column_title):
        pass
    def print_call_line(self, name_size, source, call_dict, arrow="->"):
        pass
    def print_title(self):
        pass
    def print_line(self, func):  # hack: should print percentages
        pass
class TupleComp:
    def __init__(self, comp_select_list):
        pass
    def compare (self, left, right):
        pass
def func_strip_path(func_name):
   pass
def func_get_function_name(func):
   pass
def func_std_string(func_name): # match what old profile produced
   pass
def add_func_stats(target, source):
   pass
def add_callers(target, source):
   pass
def count_calls(callers):
   pass
    class ProfileBrowser(cmd.Cmd):
        def __init__(self, profile=None):
                pass
        def generic(self, fn, line):
                pass
        def generic_help(self):
                pass
        def do_add(self, line):
                pass
        def help_add(self):
                pass
        def do_callees(self, line):
                pass
        def help_callees(self):
                pass
        def do_callers(self, line):
                pass
        def help_callers(self):
                pass
        def do_EOF(self, line):
                pass
        def help_EOF(self):
                pass
        def do_quit(self, line):
                pass
        def help_quit(self):
                pass
        def do_read(self, line):
                pass
        def help_read(self):
                pass
        def do_reverse(self, line):
                pass
        def help_reverse(self):
                pass
        def do_sort(self, line):
                pass
        def help_sort(self):
                pass
        def complete_sort(self, text, *args):
                pass
        def do_stats(self, line):
                pass
        def help_stats(self):
                pass
        def do_strip(self, line):
                pass
        def help_strip(self):
                pass
        def help_help(self):
                pass
        def postcmd(self, stop, line):
                pass
"""# pty.py #"""
def openpty():
   pass
def master_open():
   pass
def _open_terminal():
   pass
def slave_open(tty_name):
   pass
def fork():
   pass
def _writen(fd, data):
   pass
def _read(fd):
   pass
def _copy(master_fd, master_read=_read, stdin_read=_read):
   pass
def spawn(argv, master_read=_read, stdin_read=_read):
   pass
"""# pyclbr.py #"""
class _Object:
    def __init__(self, module, name, file, lineno, parent):
        pass
    def _addchild(self, name, obj):
        pass
class Function(_Object):
    def __init__(self, module, name, file, lineno, parent=None):
        pass
class Class(_Object):
    def __init__(self, module, name, super, file, lineno, parent=None):
        pass
    def _addmethod(self, name, lineno):
        pass
def _nest_function(ob, func_name, lineno):
   pass
def _nest_class(ob, class_name, lineno, super=None):
   pass
def readmodule(module, path=None):
   pass
def readmodule_ex(module, path=None):
   pass
def _readmodule(module, path, inpackage=None):
   pass
def _create_tree(fullmodule, path, fname, source, tree, inpackage):
   pass
def _getnamelist(g):
   pass
def _getname(g):
   pass
def _main():
   pass
"""# pydoc.py #"""
def pathdirs():
   pass
def _findclass(func):
   pass
def _finddoc(obj):
   pass
def _getowndoc(obj):
   pass
def _getdoc(object):
   pass
def getdoc(object):
   pass
def splitdoc(doc):
   pass
def classname(object, modname):
   pass
def isdata(object):
   pass
def replace(text, *pairs):
   pass
def cram(text, maxlen):
   pass
def stripid(text):
   pass
def _is_bound_method(fn):
   pass
def allmethods(cl):
   pass
def _split_list(s, predicate):
   pass
def visiblename(name, all=None, obj=None):
   pass
def classify_class_attrs(object):
   pass
def sort_attributes(attrs, object):
   pass
def ispackage(path):
   pass
def source_synopsis(file):
   pass
def synopsis(filename, cache={}):
   pass
class ErrorDuringImport(Exception):
    def __init__(self, filename, exc_info):
        pass
    def __str__(self):
        pass
def importfile(path):
   pass
def safeimport(path, forceload=0, cache={}):
   pass
class Doc:
    def document(self, object, name=None, *args):
        pass
    def fail(self, object, name=None, *args):
        pass
    def getdocloc(self, object, basedir=sysconfig.get_path('stdlib')):
        pass
class HTMLRepr(Repr):
    def __init__(self):
        pass
    def escape(self, text):
        pass
    def repr(self, object):
        pass
    def repr_string(self, x, level):
        pass
    def repr_instance(self, x, level):
        pass
class HTMLDoc(Doc):
    def page(self, title, contents):
        pass
    def heading(self, title, fgcol, bgcol, extras=''):
        pass
    def bigsection(self, title, *args):
        pass
    def preformat(self, text):
        pass
    def multicolumn(self, list, format, cols=4):
        pass
    def grey(self, text): return '<font color="#909090">%s</font>' % text
        pass
    def namelink(self, name, *dicts):
        pass
    def classlink(self, object, modname):
        pass
    def modulelink(self, object):
        pass
    def modpkglink(self, modpkginfo):
        pass
    def filelink(self, url, path):
        pass
    def markup(self, text, escape=None, funcs={}, classes={}, methods={}):
        pass
    def formattree(self, tree, modname, parent=None):
        pass
    def docmodule(self, object, name=None, mod=None, *ignored):
        pass
        class HorizontalRule:
            def __init__(self):
                        pass
            def maybe(self):
                        pass
        def spill(msg, attrs, predicate):
                pass
        def spilldescriptors(msg, attrs, predicate):
                pass
        def spilldata(msg, attrs, predicate):
                pass
    def formatvalue(self, object):
        pass
    def docdata(self, object, name=None, mod=None, cl=None):
        pass
    def docother(self, object, name=None, mod=None, *ignored):
        pass
    def index(self, dir, shadowed=None):
        pass
class TextRepr(Repr):
    def __init__(self):
        pass
    def repr_string(self, x, level):
        pass
    def repr_instance(self, x, level):
        pass
class TextDoc(Doc):
    def bold(self, text):
        pass
    def indent(self, text, prefix='    '):
        pass
    def section(self, title, contents):
        pass
    def formattree(self, tree, modname, parent=None, prefix=''):
        pass
    def docmodule(self, object, name=None, mod=None):
        pass
    def docclass(self, object, name=None, mod=None, *ignored):
        pass
        def makename(c, m=object.__module__):
                pass
        class HorizontalRule:
            def __init__(self):
                        pass
            def maybe(self):
                        pass
        def spill(msg, attrs, predicate):
                pass
        def spilldescriptors(msg, attrs, predicate):
                pass
        def spilldata(msg, attrs, predicate):
                pass
    def formatvalue(self, object):
        pass
    def docroutine(self, object, name=None, mod=None, cl=None):
        pass
    def docdata(self, object, name=None, mod=None, cl=None):
        pass
    def docother(self, object, name=None, mod=None, parent=None, maxlen=None, doc=None):
        pass
class _PlainTextDoc(TextDoc):
    def bold(self, text):
        pass
def pager(text):
   pass
def getpager():
   pass
def plain(text):
   pass
def pipepager(text, cmd):
   pass
def tempfilepager(text, cmd):
   pass
def _escape_stdout(text):
   pass
def ttypager(text):
   pass
def plainpager(text):
   pass
def describe(thing):
   pass
def locate(path, forceload=0):
   pass
def resolve(thing, forceload=0):
   pass
def writedoc(thing, forceload=0):
   pass
def writedocs(dir, pkgpath='', done=None):
   pass
class Helper:
    def __init__(self, input=None, output=None):
        pass
    def input(self):
        pass
    def output(self):
        pass
    def __repr__(self):
        pass
    def __call__(self, request=_GoInteractive):
        pass
    def interact(self):
        pass
    def getline(self, prompt):
        pass
    def help(self, request):
        pass
    def intro(self):
        pass
    def list(self, items, columns=4, width=80):
        pass
    def listkeywords(self):
        pass
    def listsymbols(self):
        pass
    def listtopics(self):
        pass
    def showtopic(self, topic, more_xrefs=''):
        pass
    def _gettopic(self, topic, more_xrefs=''):
        pass
    def showsymbol(self, symbol):
        pass
    def listmodules(self, key=''):
        pass
            def callback(path, modname, desc, modules=modules):
                        pass
            def onerror(modname):
                        pass
class ModuleScanner:
    def run(self, callback, key=None, completer=None, onerror=None):
        pass
def apropos(key):
   pass
    def callback(path, modname, desc):
        pass
    def onerror(modname):
        pass
def _start_server(urlhandler, hostname, port):
   pass
    class DocHandler(http.server.BaseHTTPRequestHandler):
        def do_GET(self):
                pass
        def log_message(self, *args):
                pass
    class DocServer(http.server.HTTPServer):
        def __init__(self, host, port, callback):
                pass
        def serve_until_quit(self):
                pass
        def server_activate(self):
                pass
    class ServerThread(threading.Thread):
        def __init__(self, urlhandler, host, port):
                pass
        def run(self):
                pass
        def ready(self, server):
                pass
        def stop(self):
                pass
def _url_handler(url, content_type="text/html"):
   pass
    class _HTMLDoc(HTMLDoc):
        def page(self, title, contents):
                pass
        def filelink(self, url, path):
                pass
    def html_navbar():
        pass
    def html_index():
        pass
        def bltinlink(name):
                pass
    def html_search(key):
        pass
        def callback(path, modname, desc):
                pass
            def onerror(modname):
                        pass
        def bltinlink(name):
                pass
    def html_getfile(path):
        pass
    def html_topics():
        pass
        def bltinlink(name):
                pass
    def html_keywords():
        pass
        def bltinlink(name):
                pass
    def html_topicpage(topic):
        pass
            def bltinlink(name):
                        pass
    def html_getobj(url):
        pass
    def html_error(url, exc):
        pass
    def get_html_page(url):
        pass
def browse(port=0, *, open_browser=True, hostname='localhost'):
   pass
def ispath(x):
   pass
def _get_revised_path(given_path, argv0):
   pass
def _adjust_cli_sys_path():
   pass
def cli():
   pass
    class BadUsage(Exception): pass
"""# py_compile.py #"""
class PyCompileError(Exception):
    def __init__(self, exc_type, exc_value, file, msg=''):
        pass
    def __str__(self):
        pass
class PycInvalidationMode(enum.Enum):
def _get_default_invalidation_mode():
   pass
def main(args=None):
   pass
"""# queue.py #"""
    class Empty(Exception):
class Full(Exception):
class Queue:
    def __init__(self, maxsize=0):
        pass
    def task_done(self):
        pass
    def join(self):
        pass
    def qsize(self):
        pass
    def empty(self):
        pass
    def full(self):
        pass
    def put(self, item, block=True, timeout=None):
        pass
    def get(self, block=True, timeout=None):
        pass
    def put_nowait(self, item):
        pass
    def get_nowait(self):
        pass
    def _init(self, maxsize):
        pass
    def _qsize(self):
        pass
    def _put(self, item):
        pass
    def _get(self):
        pass
class PriorityQueue(Queue):
    def _init(self, maxsize):
        pass
    def _qsize(self):
        pass
    def _put(self, item):
        pass
    def _get(self):
        pass
class LifoQueue(Queue):
    def _init(self, maxsize):
        pass
    def _qsize(self):
        pass
    def _put(self, item):
        pass
    def _get(self):
        pass
class _PySimpleQueue:
    def __init__(self):
        pass
    def put(self, item, block=True, timeout=None):
        pass
    def get(self, block=True, timeout=None):
        pass
    def put_nowait(self, item):
        pass
    def get_nowait(self):
        pass
    def empty(self):
        pass
    def qsize(self):
        pass
"""# quopri.py #"""
def needsquoting(c, quotetabs, header):
   pass
def quote(c):
   pass
def encode(input, output, quotetabs, header=False):
   pass
    def write(s, output=output, lineEnd=b'\n'):
        pass
def encodestring(s, quotetabs=False, header=False):
   pass
def decode(input, output, header=False):
   pass
def decodestring(s, header=False):
   pass
def ishex(c):
   pass
def unhex(s):
   pass
def main():
   pass
"""# random.py #"""
class Random(_random.Random):
    def __init__(self, x=None):
        pass
    def seed(self, a=None, version=2):
        pass
    def getstate(self):
        pass
    def setstate(self, state):
        pass
    def __getstate__(self):  # for pickle
        pass
    def __setstate__(self, state):  # for pickle
        pass
    def __reduce__(self):
        pass
    def __init_subclass__(cls, /, **kwargs):
        pass
    def _randbelow_with_getrandbits(self, n):
        pass
    def _randbelow_without_getrandbits(self, n, maxsize=1<<BPF):
        pass
    def randbytes(self, n):
        pass
    def randrange(self, start, stop=None, step=1):
        pass
    def randint(self, a, b):
        pass
    def choice(self, seq):
        pass
    def shuffle(self, x, random=None):
        pass
    def sample(self, population, k, *, counts=None):
        pass
    def choices(self, population, weights=None, *, cum_weights=None, k=1):
        pass
    def uniform(self, a, b):
        pass
    def triangular(self, low=0.0, high=1.0, mode=None):
        pass
    def normalvariate(self, mu, sigma):
        pass
    def gauss(self, mu, sigma):
        pass
    def lognormvariate(self, mu, sigma):
        pass
    def expovariate(self, lambd):
        pass
    def vonmisesvariate(self, mu, kappa):
        pass
    def gammavariate(self, alpha, beta):
        pass
    def betavariate(self, alpha, beta):
        pass
    def paretovariate(self, alpha):
        pass
    def weibullvariate(self, alpha, beta):
        pass
class SystemRandom(Random):
    def random(self):
        pass
    def getrandbits(self, k):
        pass
    def randbytes(self, n):
        pass
    def seed(self, *args, **kwds):
        pass
    def _notimplemented(self, *args, **kwds):
        pass
def _test_generator(n, func, args):
   pass
def _test(N=2000):
   pass
"""# re.py #"""
class RegexFlag(enum.IntFlag):
    def __repr__(self):
        pass
def match(pattern, string, flags=0):
   pass
def fullmatch(pattern, string, flags=0):
   pass
def search(pattern, string, flags=0):
   pass
def sub(pattern, repl, string, count=0, flags=0):
   pass
def subn(pattern, repl, string, count=0, flags=0):
   pass
def split(pattern, string, maxsplit=0, flags=0):
   pass
def findall(pattern, string, flags=0):
   pass
def finditer(pattern, string, flags=0):
   pass
def compile(pattern, flags=0):
   pass
def purge():
   pass
def template(pattern, flags=0):
   pass
def escape(pattern):
   pass
def _compile(pattern, flags):
   pass
def _compile_repl(repl, pattern):
   pass
def _expand(pattern, match, template):
   pass
def _subx(pattern, template):
   pass
    def filter(match, template=template):
        pass
def _pickle(p):
   pass
class Scanner:
    def __init__(self, lexicon, flags=0):
        pass
    def scan(self, string):
        pass
"""# reprlib.py #"""
def recursive_repr(fillvalue='...'):
   pass
    def decorating_function(user_function):
        pass
        def wrapper(self):
                pass
class Repr:
    def __init__(self):
        pass
    def repr(self, x):
        pass
    def _repr_iterable(self, x, level, left, right, maxiter, trail=''):
        pass
    def repr_tuple(self, x, level):
        pass
    def repr_list(self, x, level):
        pass
    def repr_array(self, x, level):
        pass
    def repr_set(self, x, level):
        pass
    def repr_frozenset(self, x, level):
        pass
    def repr_deque(self, x, level):
        pass
    def repr_dict(self, x, level):
        pass
    def repr_str(self, x, level):
        pass
    def repr_int(self, x, level):
        pass
    def repr_instance(self, x, level):
        pass
def _possibly_sorted(x):
   pass
"""# rlcompleter.py #"""
class Completer:
    def __init__(self, namespace = None):
        pass
    def complete(self, text, state):
        pass
    def _callable_postfix(self, val, word):
        pass
    def global_matches(self, text):
        pass
    def attr_matches(self, text):
        pass
def get_class_members(klass):
   pass
"""# runpy.py #"""
class _TempModule(object):
    def __init__(self, mod_name):
        pass
    def __enter__(self):
        pass
    def __exit__(self, *args):
        pass
    def __init__(self, value):
        pass
    def __enter__(self):
        pass
    def __exit__(self, *args):
        pass
def _get_module_details(mod_name, error=ImportError):
   pass
class _Error(Exception):
def _run_module_as_main(mod_name, alter_argv=True):
   pass
def _get_main_module_details(error=ImportError):
   pass
def _get_code_from_file(run_name, fname):
   pass
def run_path(path_name, init_globals=None, run_name=None):
   pass
"""# sched.py #"""
class Event(namedtuple('Event', 'time, priority, action, argument, kwargs')):
    def __eq__(s, o): return (s.time, s.priority) == (o.time, o.priority)
        pass
    def __lt__(s, o): return (s.time, s.priority) <  (o.time, o.priority)
        pass
    def __le__(s, o): return (s.time, s.priority) <= (o.time, o.priority)
        pass
    def __gt__(s, o): return (s.time, s.priority) >  (o.time, o.priority)
        pass
    def __ge__(s, o): return (s.time, s.priority) >= (o.time, o.priority)
        pass
class scheduler:
    def __init__(self, timefunc=_time, delayfunc=time.sleep):
        pass
    def enterabs(self, time, priority, action, argument=(), kwargs=_sentinel):
        pass
    def enter(self, delay, priority, action, argument=(), kwargs=_sentinel):
        pass
    def cancel(self, event):
        pass
    def empty(self):
        pass
    def run(self, blocking=True):
        pass
    def queue(self):
        pass
"""# secrets.py #"""
def randbelow(exclusive_upper_bound):
   pass
def token_bytes(nbytes=None):
   pass
def token_hex(nbytes=None):
   pass
def token_urlsafe(nbytes=None):
   pass
"""# selectors.py #"""
def _fileobj_to_fd(fileobj):
   pass
class _SelectorMapping(Mapping):
    def __init__(self, selector):
        pass
    def __len__(self):
        pass
    def __getitem__(self, fileobj):
        pass
    def __iter__(self):
        pass
class BaseSelector(metaclass=ABCMeta):
    def register(self, fileobj, events, data=None):
        pass
    def unregister(self, fileobj):
        pass
    def modify(self, fileobj, events, data=None):
        pass
    def select(self, timeout=None):
        pass
    def close(self):
        pass
    def get_key(self, fileobj):
        pass
    def get_map(self):
        pass
    def __enter__(self):
        pass
    def __exit__(self, *args):
        pass
class _BaseSelectorImpl(BaseSelector):
    def __init__(self):
        pass
    def _fileobj_lookup(self, fileobj):
        pass
    def register(self, fileobj, events, data=None):
        pass
    def unregister(self, fileobj):
        pass
    def modify(self, fileobj, events, data=None):
        pass
    def close(self):
        pass
    def get_map(self):
        pass
    def _key_from_fd(self, fd):
        pass
class SelectSelector(_BaseSelectorImpl):
    def __init__(self):
        pass
    def register(self, fileobj, events, data=None):
        pass
    def unregister(self, fileobj):
        pass
        def _select(self, r, w, _, timeout=None):
                pass
    def select(self, timeout=None):
        pass
class _PollLikeSelector(_BaseSelectorImpl):
    def __init__(self):
        pass
    def register(self, fileobj, events, data=None):
        pass
    def unregister(self, fileobj):
        pass
    def modify(self, fileobj, events, data=None):
        pass
    def select(self, timeout=None):
        pass
    class PollSelector(_PollLikeSelector):
    class EpollSelector(_PollLikeSelector):
        def fileno(self):
                pass
        def select(self, timeout=None):
                pass
        def close(self):
                pass
    class DevpollSelector(_PollLikeSelector):
        def fileno(self):
                pass
        def close(self):
                pass
    class KqueueSelector(_BaseSelectorImpl):
        def __init__(self):
                pass
        def fileno(self):
                pass
        def register(self, fileobj, events, data=None):
                pass
        def unregister(self, fileobj):
                pass
        def select(self, timeout=None):
                pass
        def close(self):
                pass
def _can_use(method):
   pass
"""# shelve.py #"""
class _ClosedDict(collections.abc.MutableMapping):
    def closed(self, *args):
        pass
    def __repr__(self):
        pass
class Shelf(collections.abc.MutableMapping):
    def __iter__(self):
        pass
    def __len__(self):
        pass
    def __contains__(self, key):
        pass
    def get(self, key, default=None):
        pass
    def __getitem__(self, key):
        pass
    def __setitem__(self, key, value):
        pass
    def __delitem__(self, key):
        pass
    def __enter__(self):
        pass
    def __exit__(self, type, value, traceback):
        pass
    def close(self):
        pass
    def __del__(self):
        pass
    def sync(self):
        pass
class BsdDbShelf(Shelf):
    def set_location(self, key):
        pass
    def next(self):
        pass
    def previous(self):
        pass
    def first(self):
        pass
    def last(self):
        pass
class DbfilenameShelf(Shelf):
    def __init__(self, filename, flag='c', protocol=None, writeback=False):
        pass
def open(filename, flag='c', protocol=None, writeback=False):
   pass
"""# shlex.py #"""
"""# shutil.py #"""
class Error(OSError):
class SameFileError(Error):
class SpecialFileError(OSError):
class ExecError(OSError):
class ReadError(OSError):
class RegistryError(Exception):
class _GiveupOnFastCopy(Exception):
def _fastcopy_fcopyfile(fsrc, fdst, flags):
   pass
def _fastcopy_sendfile(fsrc, fdst):
   pass
def _copyfileobj_readinto(fsrc, fdst, length=COPY_BUFSIZE):
   pass
def copyfileobj(fsrc, fdst, length=0):
   pass
def _samefile(src, dst):
   pass
def _stat(fn):
   pass
def _islink(fn):
   pass
def copyfile(src, dst, *, follow_symlinks=True):
   pass
def copymode(src, dst, *, follow_symlinks=True):
   pass
    def _copyxattr(src, dst, *, follow_symlinks=True):
        pass
    def _copyxattr(*args, **kwargs):
        pass
def copystat(src, dst, *, follow_symlinks=True):
   pass
    def _nop(*args, ns=None, follow_symlinks=None):
        pass
        def lookup(name):
                pass
        def lookup(name):
                pass
def copy(src, dst, *, follow_symlinks=True):
   pass
def ignore_patterns(*patterns):
   pass
    def _ignore_patterns(path, names):
        pass
    def _rmtree_isdir(entry):
        pass
    def _rmtree_islink(path):
        pass
    def _rmtree_isdir(entry):
        pass
    def _rmtree_islink(path):
        pass
def _rmtree_unsafe(path, onerror):
   pass
def _rmtree_safe_fd(topfd, path, onerror):
   pass
def rmtree(path, ignore_errors=False, onerror=None):
   pass
        def onerror(*args):
                pass
        def onerror(*args):
                pass
def _basename(path):
   pass
def move(src, dst, copy_function=copy2):
   pass
def _destinsrc(src, dst):
   pass
def _get_gid(name):
   pass
def _get_uid(name):
   pass
    def _set_uid_gid(tarinfo):
        pass
def _make_zipfile(base_name, base_dir, verbose=0, dry_run=0, logger=None):
   pass
def get_archive_formats():
   pass
def register_archive_format(name, function, extra_args=None, description=''):
   pass
def unregister_archive_format(name):
   pass
def get_unpack_formats():
   pass
def _check_unpack_options(extensions, function, extra_args):
   pass
def unregister_unpack_format(name):
   pass
def _ensure_directory(path):
   pass
def _unpack_zipfile(filename, extract_dir):
   pass
def _unpack_tarfile(filename, extract_dir):
   pass
def _find_unpack_format(filename):
   pass
def unpack_archive(filename, extract_dir=None, format=None):
   pass
    def disk_usage(path):
        pass
    def disk_usage(path):
        pass
def chown(path, user=None, group=None):
   pass
def get_terminal_size(fallback=(80, 24)):
   pass
def _access_check(fn, mode):
   pass
def which(cmd, mode=os.F_OK | os.X_OK, path=None):
   pass
"""# signal.py #"""
def _int_to_enum(value, enum_klass):
   pass
def _enum_to_int(value):
   pass
def signal(signalnum, handler):
   pass
def getsignal(signalnum):
   pass
    def pthread_sigmask(how, mask):
        pass
    def sigpending():
        pass
    def sigwait(sigset):
        pass
    def valid_signals():
        pass
"""# site.py #"""
def makepath(*paths):
   pass
def abs_paths():
   pass
def removeduppaths():
   pass
def _init_pathinfo():
   pass
def addpackage(sitedir, name, known_paths):
   pass
def addsitedir(sitedir, known_paths=None):
   pass
def check_enableusersite():
   pass
def _getuserbase():
   pass
    def joinuser(*args):
        pass
def _get_path(userbase):
   pass
def getuserbase():
   pass
def getusersitepackages():
   pass
def addusersitepackages(known_paths):
   pass
def getsitepackages(prefixes=None):
   pass
def addsitepackages(known_paths, prefixes=None):
   pass
def setquit():
   pass
def setcopyright():
   pass
def sethelper():
   pass
def enablerlcompleter():
   pass
    def register_readline():
        pass
            def write_history():
                        pass
def venv(known_paths):
   pass
def execsitecustomize():
   pass
def execusercustomize():
   pass
def main():
   pass
def _script():
   pass
"""# smtpd.py #"""
class Devnull:
    def write(self, msg): pass
        pass
    def flush(self): pass
        pass
def usage(code, msg=''):
   pass
class SMTPChannel(asynchat.async_chat):
    def max_command_size_limit(self):
        pass
    def _set_post_data_state(self):
        pass
    def _set_rset_state(self):
        pass
    def __server(self):
        pass
    def __server(self, value):
        pass
    def __line(self):
        pass
    def __line(self, value):
        pass
    def __state(self):
        pass
    def __state(self, value):
        pass
    def __greeting(self):
        pass
    def __greeting(self, value):
        pass
    def __mailfrom(self):
        pass
    def __mailfrom(self, value):
        pass
    def __rcpttos(self):
        pass
    def __rcpttos(self, value):
        pass
    def __data(self):
        pass
    def __data(self, value):
        pass
    def __fqdn(self):
        pass
    def __fqdn(self, value):
        pass
    def __peer(self):
        pass
    def __peer(self, value):
        pass
    def __conn(self):
        pass
    def __conn(self, value):
        pass
    def __addr(self):
        pass
    def __addr(self, value):
        pass
    def push(self, msg):
        pass
    def collect_incoming_data(self, data):
        pass
    def found_terminator(self):
        pass
    def smtp_HELO(self, arg):
        pass
    def smtp_EHLO(self, arg):
        pass
    def smtp_NOOP(self, arg):
        pass
    def smtp_QUIT(self, arg):
        pass
    def _strip_command_keyword(self, keyword, arg):
        pass
    def _getaddr(self, arg):
        pass
    def _getparams(self, params):
        pass
    def smtp_HELP(self, arg):
        pass
    def smtp_VRFY(self, arg):
        pass
    def smtp_MAIL(self, arg):
        pass
    def smtp_RCPT(self, arg):
        pass
    def smtp_RSET(self, arg):
        pass
    def smtp_DATA(self, arg):
        pass
    def smtp_EXPN(self, arg):
        pass
class SMTPServer(asyncore.dispatcher):
    def handle_accepted(self, conn, addr):
        pass
    def process_message(self, peer, mailfrom, rcpttos, data, **kwargs):
        pass
class DebuggingServer(SMTPServer):
    def _print_message_content(self, peer, data):
        pass
    def process_message(self, peer, mailfrom, rcpttos, data, **kwargs):
        pass
class PureProxy(SMTPServer):
    def __init__(self, *args, **kwargs):
        pass
    def process_message(self, peer, mailfrom, rcpttos, data):
        pass
    def _deliver(self, mailfrom, rcpttos, data):
        pass
class MailmanProxy(PureProxy):
    def __init__(self, *args, **kwargs):
        pass
    def process_message(self, peer, mailfrom, rcpttos, data):
        pass
class Options:
def parseargs():
   pass
"""# smtplib.py #"""
class SMTPException(OSError):
class SMTPNotSupportedError(SMTPException):
class SMTPServerDisconnected(SMTPException):
class SMTPResponseException(SMTPException):
    def __init__(self, code, msg):
        pass
class SMTPSenderRefused(SMTPResponseException):
    def __init__(self, code, msg, sender):
        pass
class SMTPRecipientsRefused(SMTPException):
    def __init__(self, recipients):
        pass
class SMTPDataError(SMTPResponseException):
class SMTPConnectError(SMTPResponseException):
class SMTPHeloError(SMTPResponseException):
class SMTPAuthenticationError(SMTPResponseException):
def quoteaddr(addrstring):
   pass
def _addr_only(addrstring):
   pass
def quotedata(data):
   pass
def _quote_periods(bindata):
   pass
def _fix_eols(data):
   pass
class SMTP:
    def __enter__(self):
        pass
    def __exit__(self, *args):
        pass
    def set_debuglevel(self, debuglevel):
        pass
    def _print_debug(self, *args):
        pass
    def _get_socket(self, host, port, timeout):
        pass
    def connect(self, host='localhost', port=0, source_address=None):
        pass
    def send(self, s):
        pass
    def putcmd(self, cmd, args=""):
        pass
    def getreply(self):
        pass
    def docmd(self, cmd, args=""):
        pass
    def helo(self, name=''):
        pass
    def ehlo(self, name=''):
        pass
    def has_extn(self, opt):
        pass
    def help(self, args=''):
        pass
    def rset(self):
        pass
    def _rset(self):
        pass
    def noop(self):
        pass
    def mail(self, sender, options=()):
        pass
    def rcpt(self, recip, options=()):
        pass
    def data(self, msg):
        pass
    def verify(self, address):
        pass
    def expn(self, address):
        pass
    def ehlo_or_helo_if_needed(self):
        pass
    def auth(self, mechanism, authobject, *, initial_response_ok=True):
        pass
    def auth_plain(self, challenge=None):
        pass
    def auth_login(self, challenge=None):
        pass
    def login(self, user, password, *, initial_response_ok=True):
        pass
    def starttls(self, keyfile=None, certfile=None, context=None):
        pass
    def close(self):
        pass
    def quit(self):
        pass
    class SMTP_SSL(SMTP):
        def _get_socket(self, host, port, timeout):
                pass
class LMTP(SMTP):
    def connect(self, host='localhost', port=0, source_address=None):
        pass
    def prompt(prompt):
        pass
"""# sndhdr.py #"""
def what(filename):
   pass
def whathdr(filename):
   pass
def test_aifc(h, f):
   pass
def test_au(h, f):
   pass
def test_hcom(h, f):
   pass
def test_voc(h, f):
   pass
def test_wav(h, f):
   pass
def test_sndt(h, f):
   pass
def test_sndr(h, f):
   pass
def get_long_be(b):
   pass
def get_long_le(b):
   pass
def get_short_be(b):
   pass
def get_short_le(b):
   pass
def test():
   pass
def testall(list, recursive, toplevel):
   pass
"""# socket.py #"""
def _intenum_converter(value, enum_klass):
   pass
class _GiveupOnSendfile(Exception): pass
class socket(_socket.socket):
    def __init__(self, family=-1, type=-1, proto=-1, fileno=None):
        pass
    def __enter__(self):
        pass
    def __exit__(self, *args):
        pass
    def __repr__(self):
        pass
    def __getstate__(self):
        pass
    def dup(self):
        pass
    def accept(self):
        pass
        def _sendfile_use_sendfile(self, file, offset=0, count=None):
                pass
        def _sendfile_use_sendfile(self, file, offset=0, count=None):
                pass
    def _sendfile_use_send(self, file, offset=0, count=None):
        pass
    def _check_sendfile_params(self, file, offset, count):
        pass
    def sendfile(self, file, offset=0, count=None):
        pass
    def _decref_socketios(self):
        pass
    def _real_close(self, _ss=_socket.socket):
        pass
    def close(self):
        pass
    def detach(self):
        pass
    def family(self):
        pass
    def type(self):
        pass
        def get_inheritable(self):
                pass
        def set_inheritable(self, inheritable):
                pass
        def get_inheritable(self):
                pass
        def set_inheritable(self, inheritable):
                pass
def fromfd(fd, family, type, proto=0):
   pass
    def send_fds(sock, buffers, fds, flags=0, address=None):
        pass
    def recv_fds(sock, bufsize, maxfds, flags=0):
        pass
    def fromshare(info):
        pass
    def socketpair(family=None, type=SOCK_STREAM, proto=0):
        pass
    def socketpair(family=AF_INET, type=SOCK_STREAM, proto=0):
        pass
class SocketIO(io.RawIOBase):
    def __init__(self, sock, mode):
        pass
    def readinto(self, b):
        pass
    def write(self, b):
        pass
    def readable(self):
        pass
    def writable(self):
        pass
    def seekable(self):
        pass
    def fileno(self):
        pass
    def name(self):
        pass
    def mode(self):
        pass
    def close(self):
        pass
def getfqdn(name=''):
   pass
def getaddrinfo(host, port, family=0, type=0, proto=0, flags=0):
   pass
"""# socketserver.py #"""
        class ThreadingUDPServer(ThreadingMixIn, UDPServer): pass
class BaseServer:
    def __init__(self, server_address, RequestHandlerClass):
        pass
    def server_activate(self):
        pass
    def serve_forever(self, poll_interval=0.5):
        pass
    def shutdown(self):
        pass
    def service_actions(self):
        pass
    def handle_request(self):
        pass
    def _handle_request_noblock(self):
        pass
    def handle_timeout(self):
        pass
    def verify_request(self, request, client_address):
        pass
    def process_request(self, request, client_address):
        pass
    def server_close(self):
        pass
    def finish_request(self, request, client_address):
        pass
    def shutdown_request(self, request):
        pass
    def close_request(self, request):
        pass
    def handle_error(self, request, client_address):
        pass
    def __enter__(self):
        pass
    def __exit__(self, *args):
        pass
class TCPServer(BaseServer):
    def __init__(self, server_address, RequestHandlerClass, bind_and_activate=True):
        pass
    def server_bind(self):
        pass
    def server_activate(self):
        pass
    def server_close(self):
        pass
    def fileno(self):
        pass
    def get_request(self):
        pass
    def shutdown_request(self, request):
        pass
    def close_request(self, request):
        pass
class UDPServer(TCPServer):
    def get_request(self):
        pass
    def server_activate(self):
        pass
    def shutdown_request(self, request):
        pass
    def close_request(self, request):
        pass
    class ForkingMixIn:
        def collect_children(self, *, blocking=False):
                pass
        def handle_timeout(self):
                pass
        def service_actions(self):
                pass
        def process_request(self, request, client_address):
                pass
        def server_close(self):
                pass
class ThreadingMixIn:
    def process_request_thread(self, request, client_address):
        pass
    def process_request(self, request, client_address):
        pass
    def server_close(self):
        pass
    class ForkingUDPServer(ForkingMixIn, UDPServer): pass
    class ForkingTCPServer(ForkingMixIn, TCPServer): pass
class ThreadingUDPServer(ThreadingMixIn, UDPServer): pass
class ThreadingTCPServer(ThreadingMixIn, TCPServer): pass
    class UnixStreamServer(TCPServer):
    class UnixDatagramServer(UDPServer):
    class ThreadingUnixStreamServer(ThreadingMixIn, UnixStreamServer): pass
    class ThreadingUnixDatagramServer(ThreadingMixIn, UnixDatagramServer): pass
class BaseRequestHandler:
    def __init__(self, request, client_address, server):
        pass
    def setup(self):
        pass
    def handle(self):
        pass
    def finish(self):
        pass
class StreamRequestHandler(BaseRequestHandler):
    def setup(self):
        pass
    def finish(self):
        pass
class _SocketWriter(BufferedIOBase):
    def __init__(self, sock):
        pass
    def writable(self):
        pass
    def write(self, b):
        pass
    def fileno(self):
        pass
class DatagramRequestHandler(BaseRequestHandler):
    def setup(self):
        pass
    def finish(self):
        pass
"""# sre_compile.py #"""
"""# sre_constants.py #"""
class error(Exception):
    def __init__(self, msg, pattern=None, pos=None):
        pass
class _NamedIntConstant(int):
    def __new__(cls, value, name):
        pass
    def __repr__(self):
        pass
def _makecodes(names):
   pass
    def dump(f, d, prefix):
        pass
"""# sre_parse.py #"""
class Verbose(Exception):
class State:
    def __init__(self):
        pass
    def groups(self):
        pass
    def opengroup(self, name=None):
        pass
    def closegroup(self, gid, p):
        pass
    def checkgroup(self, gid):
        pass
    def checklookbehindgroup(self, gid, source):
        pass
class SubPattern:
    def __init__(self, state, data=None):
        pass
    def dump(self, level=0):
        pass
    def __repr__(self):
        pass
    def __len__(self):
        pass
    def __delitem__(self, index):
        pass
    def __getitem__(self, index):
        pass
    def __setitem__(self, index, code):
        pass
    def insert(self, index, code):
        pass
    def append(self, code):
        pass
    def getwidth(self):
        pass
class Tokenizer:
    def __init__(self, string):
        pass
    def __next(self):
        pass
    def match(self, char):
        pass
    def get(self):
        pass
    def getwhile(self, n, charset):
        pass
    def getuntil(self, terminator, name):
        pass
    def pos(self):
        pass
    def tell(self):
        pass
    def seek(self, index):
        pass
    def error(self, msg, offset=0):
        pass
def _class_escape(source, escape):
   pass
def _escape(source, escape, state):
   pass
def _uniq(items):
   pass
def _parse_sub(source, state, verbose, nested):
   pass
def _parse(source, state, verbose, nested, first=False):
   pass
def _parse_flags(source, state, char):
   pass
def fix_flags(src, flags):
   pass
def parse(str, flags=0, state=None):
   pass
def parse_template(source, state):
   pass
    def addgroup(index, pos):
        pass
def expand_template(template, match):
   pass
"""# ssl.py #"""
class TLSVersion(_IntEnum):
class _TLSContentType(_IntEnum):
class _TLSAlertType(_IntEnum):
class _TLSMessageType(_IntEnum):
def _dnsname_match(dn, hostname):
   pass
def _inet_paton(ipname):
   pass
def _ipaddress_match(cert_ipaddress, host_ip):
   pass
def match_hostname(cert, hostname):
   pass
def get_default_verify_paths():
   pass
    def __new__(cls, oid):
        pass
    def fromnid(cls, nid):
        pass
    def fromname(cls, name):
        pass
class Purpose(_ASN1Object, _Enum):
class SSLContext(_SSLContext):
    def __new__(cls, protocol=PROTOCOL_TLS, *args, **kwargs):
        pass
    def _encode_hostname(self, hostname):
        pass
    def set_npn_protocols(self, npn_protocols):
        pass
    def set_servername_callback(self, server_name_callback):
        pass
            def shim_cb(sslobj, servername, sslctx):
                        pass
    def set_alpn_protocols(self, alpn_protocols):
        pass
    def _load_windows_store_certs(self, storename, purpose):
        pass
    def load_default_certs(self, purpose=Purpose.SERVER_AUTH):
        pass
        def minimum_version(self):
                pass
        def minimum_version(self, value):
                pass
        def maximum_version(self):
                pass
        def maximum_version(self, value):
                pass
    def options(self):
        pass
    def options(self, value):
        pass
        def hostname_checks_common_name(self):
                pass
        def hostname_checks_common_name(self, value):
                pass
        def hostname_checks_common_name(self):
                pass
    def _msg_callback(self):
        pass
        def msg_cb(conn, direction, version, content_type, msg_type, data):
                pass
    def _msg_callback(self, callback):
        pass
        def inner(conn, direction, version, content_type, msg_type, data):
                pass
    def protocol(self):
        pass
    def verify_flags(self):
        pass
    def verify_flags(self, value):
        pass
    def verify_mode(self):
        pass
    def verify_mode(self, value):
        pass
class SSLObject:
    def __init__(self, *args, **kwargs):
        pass
    def context(self):
        pass
    def context(self, ctx):
        pass
    def session(self):
        pass
    def session(self, session):
        pass
    def session_reused(self):
        pass
    def server_side(self):
        pass
    def server_hostname(self):
        pass
    def read(self, len=1024, buffer=None):
        pass
    def write(self, data):
        pass
    def getpeercert(self, binary_form=False):
        pass
    def selected_npn_protocol(self):
        pass
    def selected_alpn_protocol(self):
        pass
    def cipher(self):
        pass
    def shared_ciphers(self):
        pass
    def compression(self):
        pass
    def pending(self):
        pass
    def do_handshake(self):
        pass
    def unwrap(self):
        pass
    def get_channel_binding(self, cb_type="tls-unique"):
        pass
    def version(self):
        pass
    def verify_client_post_handshake(self):
        pass
def _sslcopydoc(func):
   pass
class SSLSocket(socket):
    def __init__(self, *args, **kwargs):
        pass
    def context(self):
        pass
    def context(self, ctx):
        pass
    def session(self):
        pass
    def session(self, session):
        pass
    def session_reused(self):
        pass
    def dup(self):
        pass
    def _checkClosed(self, msg=None):
        pass
    def _check_connected(self):
        pass
    def read(self, len=1024, buffer=None):
        pass
    def write(self, data):
        pass
    def getpeercert(self, binary_form=False):
        pass
    def selected_npn_protocol(self):
        pass
    def selected_alpn_protocol(self):
        pass
    def cipher(self):
        pass
    def shared_ciphers(self):
        pass
    def compression(self):
        pass
    def send(self, data, flags=0):
        pass
    def sendto(self, data, flags_or_addr, addr=None):
        pass
    def sendmsg(self, *args, **kwargs):
        pass
    def sendall(self, data, flags=0):
        pass
    def sendfile(self, file, offset=0, count=None):
        pass
    def recv(self, buflen=1024, flags=0):
        pass
    def recv_into(self, buffer, nbytes=None, flags=0):
        pass
    def recvfrom(self, buflen=1024, flags=0):
        pass
    def recvfrom_into(self, buffer, nbytes=None, flags=0):
        pass
    def recvmsg(self, *args, **kwargs):
        pass
    def recvmsg_into(self, *args, **kwargs):
        pass
    def pending(self):
        pass
    def shutdown(self, how):
        pass
    def unwrap(self):
        pass
    def verify_client_post_handshake(self):
        pass
    def _real_close(self):
        pass
    def do_handshake(self, block=False):
        pass
    def _real_connect(self, addr, connect_ex):
        pass
    def connect(self, addr):
        pass
    def connect_ex(self, addr):
        pass
    def accept(self):
        pass
    def get_channel_binding(self, cb_type="tls-unique"):
        pass
    def version(self):
        pass
def cert_time_to_seconds(cert_time):
   pass
def DER_cert_to_PEM_cert(der_cert_bytes):
   pass
def PEM_cert_to_DER_cert(pem_cert_string):
   pass
def get_server_certificate(addr, ssl_version=PROTOCOL_TLS, ca_certs=None):
   pass
def get_protocol_name(protocol_code):
   pass
"""# stat.py #"""
def S_IMODE(mode):
   pass
def S_IFMT(mode):
   pass
def S_ISDIR(mode):
   pass
def S_ISCHR(mode):
   pass
def S_ISBLK(mode):
   pass
def S_ISREG(mode):
   pass
def S_ISFIFO(mode):
   pass
def S_ISLNK(mode):
   pass
def S_ISSOCK(mode):
   pass
def S_ISDOOR(mode):
   pass
def S_ISPORT(mode):
   pass
def S_ISWHT(mode):
   pass
def filemode(mode):
   pass
"""# statistics.py #"""
class StatisticsError(ValueError):
def _sum(data, start=0):
   pass
def _isfinite(x):
   pass
def _coerce(T, S):
   pass
def _exact_ratio(x):
   pass
def _convert(value, T):
   pass
def _find_lteq(a, x):
   pass
def _find_rteq(a, l, x):
   pass
def _fail_neg(values, errmsg='negative value'):
   pass
def mean(data):
   pass
def fmean(data):
   pass
        def count(iterable):
                pass
def geometric_mean(data):
   pass
def harmonic_mean(data):
   pass
def median(data):
   pass
def median_low(data):
   pass
def median_high(data):
   pass
def median_grouped(data, interval=1):
   pass
def mode(data):
   pass
def multimode(data):
   pass
def quantiles(data, *, n=4, method='exclusive'):
   pass
def _ss(data, c=None):
   pass
def variance(data, xbar=None):
   pass
def pvariance(data, mu=None):
   pass
def stdev(data, xbar=None):
   pass
def pstdev(data, mu=None):
   pass
def _normal_dist_inv_cdf(p, mu, sigma):
   pass
class NormalDist:
    def __init__(self, mu=0.0, sigma=1.0):
        pass
    def from_samples(cls, data):
        pass
    def samples(self, n, *, seed=None):
        pass
    def pdf(self, x):
        pass
    def cdf(self, x):
        pass
    def inv_cdf(self, p):
        pass
    def quantiles(self, n=4):
        pass
    def overlap(self, other):
        pass
    def zscore(self, x):
        pass
    def mean(self):
        pass
    def median(self):
        pass
    def mode(self):
        pass
    def stdev(self):
        pass
    def variance(self):
        pass
    def __add__(x1, x2):
        pass
    def __sub__(x1, x2):
        pass
    def __mul__(x1, x2):
        pass
    def __truediv__(x1, x2):
        pass
    def __pos__(x1):
        pass
    def __neg__(x1):
        pass
    def __rsub__(x1, x2):
        pass
    def __eq__(x1, x2):
        pass
    def __hash__(self):
        pass
    def __repr__(self):
        pass
"""# string.py #"""
def capwords(s, sep=None):
   pass
class Template:
    def __init_subclass__(cls):
        pass
    def __init__(self, template):
        pass
    def _invalid(self, mo):
        pass
    def substitute(self, mapping=_sentinel_dict, /, **kws):
        pass
        def convert(mo):
                pass
    def safe_substitute(self, mapping=_sentinel_dict, /, **kws):
        pass
        def convert(mo):
                pass
class Formatter:
    def format(self, format_string, /, *args, **kwargs):
        pass
    def vformat(self, format_string, args, kwargs):
        pass
    def get_value(self, key, args, kwargs):
        pass
    def check_unused_args(self, used_args, args, kwargs):
        pass
    def format_field(self, value, format_spec):
        pass
    def convert_field(self, value, conversion):
        pass
    def parse(self, format_string):
        pass
    def get_field(self, field_name, args, kwargs):
        pass
"""# stringprep.py #"""
"""# struct.py #"""
"""# subprocess.py #"""
class SubprocessError(Exception): pass
class CalledProcessError(SubprocessError):
    def __init__(self, returncode, cmd, output=None, stderr=None):
        pass
    def __str__(self):
        pass
    def stdout(self):
        pass
    def stdout(self, value):
        pass
class TimeoutExpired(SubprocessError):
    def __init__(self, cmd, timeout, output=None, stderr=None):
        pass
    def __str__(self):
        pass
    def stdout(self):
        pass
    def stdout(self, value):
        pass
    class STARTUPINFO:
        def copy(self):
                pass
    class Handle(int):
        def Close(self, CloseHandle=_winapi.CloseHandle):
                pass
        def Detach(self):
                pass
        def __repr__(self):
                pass
    def _cleanup():
        pass
    def _cleanup():
        pass
def _optim_args_from_interpreter_flags():
   pass
def _args_from_interpreter_flags():
   pass
def call(*popenargs, timeout=None, **kwargs):
   pass
def check_call(*popenargs, **kwargs):
   pass
def check_output(*popenargs, timeout=None, **kwargs):
   pass
class CompletedProcess(object):
    def __init__(self, args, returncode, stdout=None, stderr=None):
        pass
    def __repr__(self):
        pass
    def check_returncode(self):
        pass
def getstatusoutput(cmd):
   pass
def getoutput(cmd):
   pass
def _use_posix_spawn():
   pass
class Popen(object):
    def __repr__(self):
        pass
    def universal_newlines(self):
        pass
    def universal_newlines(self, universal_newlines):
        pass
    def _translate_newlines(self, data, encoding, errors):
        pass
    def __enter__(self):
        pass
    def __exit__(self, exc_type, value, traceback):
        pass
    def __del__(self, _maxsize=sys.maxsize, _warn=warnings.warn):
        pass
    def _get_devnull(self):
        pass
    def _stdin_write(self, input):
        pass
    def communicate(self, input=None, timeout=None):
        pass
    def poll(self):
        pass
    def _remaining_time(self, endtime):
        pass
    def wait(self, timeout=None):
        pass
        def _get_handles(self, stdin, stdout, stderr):
                pass
        def _make_inheritable(self, handle):
                pass
        def _filter_handle_list(self, handle_list):
                pass
        def _wait(self, timeout):
                pass
        def _readerthread(self, fh, buffer):
                pass
        def _communicate(self, input, endtime, orig_timeout):
                pass
        def send_signal(self, sig):
                pass
        def terminate(self):
                pass
        def _get_handles(self, stdin, stdout, stderr):
                pass
        def _try_wait(self, wait_flags):
                pass
        def _wait(self, timeout):
                pass
        def _communicate(self, input, endtime, orig_timeout):
                pass
        def _save_input(self, input):
                pass
        def send_signal(self, sig):
                pass
        def terminate(self):
                pass
        def kill(self):
                pass
"""# sunau.py #"""
class Error(Exception):
class Au_read:
    def __init__(self, f):
        pass
    def __del__(self):
        pass
    def __enter__(self):
        pass
    def __exit__(self, *args):
        pass
    def initfp(self, file):
        pass
    def getfp(self):
        pass
    def getnchannels(self):
        pass
    def getsampwidth(self):
        pass
    def getframerate(self):
        pass
    def getnframes(self):
        pass
    def getcomptype(self):
        pass
    def getcompname(self):
        pass
    def getparams(self):
        pass
    def getmarkers(self):
        pass
    def getmark(self, id):
        pass
    def readframes(self, nframes):
        pass
    def rewind(self):
        pass
    def tell(self):
        pass
    def setpos(self, pos):
        pass
    def close(self):
        pass
class Au_write:
    def __init__(self, f):
        pass
    def __del__(self):
        pass
    def __enter__(self):
        pass
    def __exit__(self, *args):
        pass
    def initfp(self, file):
        pass
    def setnchannels(self, nchannels):
        pass
    def getnchannels(self):
        pass
    def setsampwidth(self, sampwidth):
        pass
    def getsampwidth(self):
        pass
    def setframerate(self, framerate):
        pass
    def getframerate(self):
        pass
    def setnframes(self, nframes):
        pass
    def getnframes(self):
        pass
    def setcomptype(self, type, name):
        pass
    def getcomptype(self):
        pass
    def getcompname(self):
        pass
    def setparams(self, params):
        pass
    def getparams(self):
        pass
    def tell(self):
        pass
    def writeframesraw(self, data):
        pass
    def writeframes(self, data):
        pass
    def close(self):
        pass
    def _ensure_header_written(self):
        pass
    def _write_header(self):
        pass
    def _patchheader(self):
        pass
def open(f, mode=None):
   pass
"""# symbol.py #"""
"""# symtable.py #"""
def symtable(code, filename, compile_type):
   pass
class SymbolTableFactory:
    def __init__(self):
        pass
    def new(self, table, filename):
        pass
    def __call__(self, table, filename):
        pass
class SymbolTable:
    def __init__(self, raw_table, filename):
        pass
    def __repr__(self):
        pass
    def get_type(self):
        pass
    def get_id(self):
        pass
    def get_name(self):
        pass
    def get_lineno(self):
        pass
    def is_optimized(self):
        pass
    def is_nested(self):
        pass
    def has_children(self):
        pass
    def get_identifiers(self):
        pass
    def lookup(self, name):
        pass
    def get_symbols(self):
        pass
    def __check_children(self, name):
        pass
    def get_children(self):
        pass
class Function(SymbolTable):
    def __idents_matching(self, test_func):
        pass
    def get_parameters(self):
        pass
    def get_locals(self):
        pass
    def get_globals(self):
        pass
    def get_nonlocals(self):
        pass
    def get_frees(self):
        pass
class Class(SymbolTable):
    def get_methods(self):
        pass
class Symbol:
    def __init__(self, name, flags, namespaces=None, *, module_scope=False):
        pass
    def __repr__(self):
        pass
    def get_name(self):
        pass
    def is_referenced(self):
        pass
    def is_parameter(self):
        pass
    def is_global(self):
        pass
    def is_nonlocal(self):
        pass
    def is_declared_global(self):
        pass
    def is_local(self):
        pass
    def is_annotated(self):
        pass
    def is_free(self):
        pass
    def is_imported(self):
        pass
    def is_assigned(self):
        pass
    def is_namespace(self):
        pass
    def get_namespaces(self):
        pass
    def get_namespace(self):
        pass
"""# sysconfig.py #"""
def _safe_realpath(path):
   pass
def _is_python_source_dir(d):
   pass
    def _fix_pcbuild(d):
        pass
def is_python_build(check_home=False):
   pass
def _subst_vars(s, local_vars):
   pass
def _extend_dict(target_dict, other_dict):
   pass
def _expand_vars(scheme, vars):
   pass
def _get_default_scheme():
   pass
def _getuserbase():
   pass
    def joinuser(*args):
        pass
def _parse_makefile(filename, vars=None):
   pass
def get_makefile_filename():
   pass
def _get_sysconfigdata_name():
   pass
def _generate_posix_vars():
   pass
def _init_posix(vars):
   pass
def _init_non_posix(vars):
   pass
def parse_config_h(fp, vars=None):
   pass
def get_config_h_filename():
   pass
def get_scheme_names():
   pass
def get_path_names():
   pass
def get_paths(scheme=_get_default_scheme(), vars=None, expand=True):
   pass
def get_path(name, scheme=_get_default_scheme(), vars=None, expand=True):
   pass
def get_config_vars(*args):
   pass
def get_config_var(name):
   pass
def get_platform():
   pass
def get_python_version():
   pass
def _print_dict(title, data):
   pass
def _main():
   pass
"""# tabnanny.py #"""
def errprint(*args):
   pass
def main():
   pass
class NannyNag(Exception):
    def __init__(self, lineno, msg, line):
        pass
    def get_lineno(self):
        pass
    def get_msg(self):
        pass
    def get_line(self):
        pass
def check(file):
   pass
class Whitespace:
    def __init__(self, ws):
        pass
    def longest_run_of_spaces(self):
        pass
    def indent_level(self, tabsize):
        pass
    def equal(self, other):
        pass
    def not_equal_witness(self, other):
        pass
    def less(self, other):
        pass
    def not_less_witness(self, other):
        pass
def format_witnesses(w):
   pass
def process_tokens(tokens):
   pass
"""# tarfile.py #"""
def stn(s, length, encoding, errors):
   pass
def nts(s, encoding, errors):
   pass
def nti(s):
   pass
def itn(n, digits=8, format=DEFAULT_FORMAT):
   pass
def calc_chksums(buf):
   pass
def copyfileobj(src, dst, length=None, exception=OSError, bufsize=None):
   pass
def _safe_print(s):
   pass
class TarError(Exception):
class ExtractError(TarError):
class ReadError(TarError):
class CompressionError(TarError):
class StreamError(TarError):
class HeaderError(TarError):
class EmptyHeaderError(HeaderError):
class TruncatedHeaderError(HeaderError):
class EOFHeaderError(HeaderError):
class InvalidHeaderError(HeaderError):
class SubsequentHeaderError(HeaderError):
class _LowLevelFile:
    def __init__(self, name, mode):
        pass
    def close(self):
        pass
    def read(self, size):
        pass
    def write(self, s):
        pass
class _Stream:
    def __init__(self, name, mode, comptype, fileobj, bufsize):
        pass
    def __del__(self):
        pass
    def _init_write_gz(self):
        pass
    def write(self, s):
        pass
    def __write(self, s):
        pass
    def close(self):
        pass
    def _init_read_gz(self):
        pass
    def tell(self):
        pass
    def seek(self, pos=0):
        pass
    def read(self, size):
        pass
    def _read(self, size):
        pass
    def __read(self, size):
        pass
class _StreamProxy(object):
    def __init__(self, fileobj):
        pass
    def read(self, size):
        pass
    def getcomptype(self):
        pass
    def close(self):
        pass
class _FileInFile(object):
    def __init__(self, fileobj, offset, size, blockinfo=None):
        pass
    def flush(self):
        pass
    def readable(self):
        pass
    def writable(self):
        pass
    def seekable(self):
        pass
    def tell(self):
        pass
    def seek(self, position, whence=io.SEEK_SET):
        pass
    def read(self, size=None):
        pass
    def readinto(self, b):
        pass
    def close(self):
        pass
class ExFileObject(io.BufferedReader):
    def __init__(self, tarfile, tarinfo):
        pass
class TarInfo(object):
    def __init__(self, name=""):
        pass
    def path(self):
        pass
    def path(self, name):
        pass
    def linkpath(self):
        pass
    def linkpath(self, linkname):
        pass
    def __repr__(self):
        pass
    def get_info(self):
        pass
    def tobuf(self, format=DEFAULT_FORMAT, encoding=ENCODING, errors="surrogateescape"):
        pass
    def create_ustar_header(self, info, encoding, errors):
        pass
    def create_gnu_header(self, info, encoding, errors):
        pass
    def create_pax_header(self, info, encoding):
        pass
    def create_pax_global_header(cls, pax_headers):
        pass
    def _posix_split_name(self, name, encoding, errors):
        pass
    def _create_header(info, format, encoding, errors):
        pass
    def _create_payload(payload):
        pass
    def _create_gnu_long_header(cls, name, type, encoding, errors):
        pass
    def _create_pax_generic_header(cls, pax_headers, type, encoding):
        pass
    def frombuf(cls, buf, encoding, errors):
        pass
    def fromtarfile(cls, tarfile):
        pass
    def _proc_member(self, tarfile):
        pass
    def _proc_builtin(self, tarfile):
        pass
    def _proc_gnulong(self, tarfile):
        pass
    def _proc_sparse(self, tarfile):
        pass
    def _proc_pax(self, tarfile):
        pass
    def _apply_pax_info(self, pax_headers, encoding, errors):
        pass
    def _decode_pax_field(self, value, encoding, fallback_encoding, fallback_errors):
        pass
    def _block(self, count):
        pass
    def isreg(self):
        pass
    def isfile(self):
        pass
    def isdir(self):
        pass
    def issym(self):
        pass
    def islnk(self):
        pass
    def ischr(self):
        pass
    def isblk(self):
        pass
    def isfifo(self):
        pass
    def issparse(self):
        pass
    def isdev(self):
        pass
class TarFile(object):
    def open(cls, name=None, mode="r", fileobj=None, bufsize=RECORDSIZE, **kwargs):
        pass
            def not_compressed(comptype):
                        pass
    def taropen(cls, name, mode="r", fileobj=None, **kwargs):
        pass
    def gzopen(cls, name, mode="r", fileobj=None, compresslevel=9, **kwargs):
        pass
    def xzopen(cls, name, mode="r", fileobj=None, preset=None, **kwargs):
        pass
    def close(self):
        pass
    def getmember(self, name):
        pass
    def getmembers(self):
        pass
    def getnames(self):
        pass
    def gettarinfo(self, name=None, arcname=None, fileobj=None):
        pass
    def list(self, verbose=True, *, members=None):
        pass
    def add(self, name, arcname=None, recursive=True, *, filter=None):
        pass
    def addfile(self, tarinfo, fileobj=None):
        pass
    def extractall(self, path=".", members=None, *, numeric_owner=False):
        pass
    def extract(self, member, path="", set_attrs=True, *, numeric_owner=False):
        pass
    def extractfile(self, member):
        pass
    def makedir(self, tarinfo, targetpath):
        pass
    def makefile(self, tarinfo, targetpath):
        pass
    def makeunknown(self, tarinfo, targetpath):
        pass
    def makefifo(self, tarinfo, targetpath):
        pass
    def makedev(self, tarinfo, targetpath):
        pass
    def makelink(self, tarinfo, targetpath):
        pass
    def chown(self, tarinfo, targetpath, numeric_owner):
        pass
    def chmod(self, tarinfo, targetpath):
        pass
    def utime(self, tarinfo, targetpath):
        pass
    def next(self):
        pass
    def _getmember(self, name, tarinfo=None, normalize=False):
        pass
    def _load(self):
        pass
    def _check(self, mode=None):
        pass
    def _find_link_target(self, tarinfo):
        pass
    def __iter__(self):
        pass
    def _dbg(self, level, msg):
        pass
    def __enter__(self):
        pass
    def __exit__(self, type, value, traceback):
        pass
def is_tarfile(name):
   pass
def main():
   pass
"""# telnetlib.py #"""
class Telnet:
    def open(self, host, port=0, timeout=socket._GLOBAL_DEFAULT_TIMEOUT):
        pass
    def __del__(self):
        pass
    def msg(self, msg, *args):
        pass
    def set_debuglevel(self, debuglevel):
        pass
    def close(self):
        pass
    def get_socket(self):
        pass
    def fileno(self):
        pass
    def write(self, buffer):
        pass
    def read_until(self, match, timeout=None):
        pass
    def read_all(self):
        pass
    def read_some(self):
        pass
    def read_very_eager(self):
        pass
    def read_eager(self):
        pass
    def read_lazy(self):
        pass
    def read_very_lazy(self):
        pass
    def read_sb_data(self):
        pass
    def set_option_negotiation_callback(self, callback):
        pass
    def process_rawq(self):
        pass
    def rawq_getchar(self):
        pass
    def fill_rawq(self):
        pass
    def sock_avail(self):
        pass
    def interact(self):
        pass
    def mt_interact(self):
        pass
    def listener(self):
        pass
    def expect(self, list, timeout=None):
        pass
    def __enter__(self):
        pass
    def __exit__(self, type, value, traceback):
        pass
def test():
   pass
"""# tempfile.py #"""
def _exists(fn):
   pass
def _infer_return_type(*args):
   pass
def _sanitize_params(prefix, suffix, dir):
   pass
class _RandomNameSequence:
    def rng(self):
        pass
    def __iter__(self):
        pass
    def __next__(self):
        pass
def _candidate_tempdir_list():
   pass
def _get_default_tempdir():
   pass
def _get_candidate_names():
   pass
def _mkstemp_inner(dir, pre, suf, flags, output_type):
   pass
def gettempprefix():
   pass
def gettempprefixb():
   pass
def gettempdir():
   pass
def gettempdirb():
   pass
def mkstemp(suffix=None, prefix=None, dir=None, text=False):
   pass
def mkdtemp(suffix=None, prefix=None, dir=None):
   pass
def mktemp(suffix="", prefix=template, dir=None):
   pass
class _TemporaryFileCloser:
    def __init__(self, file, name, delete=True):
        pass
        def close(self, unlink=_os.unlink):
                pass
        def __del__(self):
                pass
        def close(self):
                pass
class _TemporaryFileWrapper:
    def __init__(self, file, name, delete=True):
        pass
    def __getattr__(self, name):
        pass
            def func_wrapper(*args, **kwargs):
                        pass
    def __enter__(self):
        pass
    def __exit__(self, exc, value, tb):
        pass
    def close(self):
        pass
    def __iter__(self):
        pass
class SpooledTemporaryFile:
    def _check(self, file):
        pass
    def rollover(self):
        pass
    def __enter__(self):
        pass
    def __exit__(self, exc, value, tb):
        pass
    def __iter__(self):
        pass
    def close(self):
        pass
    def closed(self):
        pass
    def encoding(self):
        pass
    def errors(self):
        pass
    def fileno(self):
        pass
    def flush(self):
        pass
    def isatty(self):
        pass
    def mode(self):
        pass
    def name(self):
        pass
    def newlines(self):
        pass
    def read(self, *args):
        pass
    def readline(self, *args):
        pass
    def readlines(self, *args):
        pass
    def seek(self, *args):
        pass
    def tell(self):
        pass
    def truncate(self, size=None):
        pass
    def write(self, s):
        pass
    def writelines(self, iterable):
        pass
class TemporaryDirectory(object):
    def __init__(self, suffix=None, prefix=None, dir=None):
        pass
    def _rmtree(cls, name):
        pass
        def onerror(func, path, exc_info):
                pass
                def resetperms(path):
                                pass
    def _cleanup(cls, name, warn_message):
        pass
    def __repr__(self):
        pass
    def __enter__(self):
        pass
    def __exit__(self, exc, value, tb):
        pass
    def cleanup(self):
        pass
"""# textwrap.py #"""
class TextWrapper:
    def _munge_whitespace(self, text):
        pass
    def _split(self, text):
        pass
    def _fix_sentence_endings(self, chunks):
        pass
    def _handle_long_word(self, reversed_chunks, cur_line, cur_len, width):
        pass
    def _wrap_chunks(self, chunks):
        pass
    def _split_chunks(self, text):
        pass
    def wrap(self, text):
        pass
    def fill(self, text):
        pass
def wrap(text, width=70, **kwargs):
   pass
def fill(text, width=70, **kwargs):
   pass
def shorten(text, width, **kwargs):
   pass
def dedent(text):
   pass
def indent(text, prefix, predicate=None):
   pass
        def predicate(line):
                pass
    def prefixed_lines():
        pass
"""# this.py #"""
"""# threading.py #"""
def setprofile(func):
   pass
def settrace(func):
   pass
def RLock(*args, **kwargs):
   pass
class _RLock:
    def __init__(self):
        pass
    def __repr__(self):
        pass
    def _at_fork_reinit(self):
        pass
    def acquire(self, blocking=True, timeout=-1):
        pass
    def release(self):
        pass
    def __exit__(self, t, v, tb):
        pass
    def _acquire_restore(self, state):
        pass
    def _release_save(self):
        pass
    def _is_owned(self):
        pass
class Condition:
    def __init__(self, lock=None):
        pass
    def _at_fork_reinit(self):
        pass
    def __enter__(self):
        pass
    def __exit__(self, *args):
        pass
    def __repr__(self):
        pass
    def _release_save(self):
        pass
    def _acquire_restore(self, x):
        pass
    def _is_owned(self):
        pass
    def wait(self, timeout=None):
        pass
    def wait_for(self, predicate, timeout=None):
        pass
    def notify(self, n=1):
        pass
    def notify_all(self):
        pass
class Semaphore:
    def __init__(self, value=1):
        pass
    def acquire(self, blocking=True, timeout=None):
        pass
    def release(self, n=1):
        pass
    def __exit__(self, t, v, tb):
        pass
class BoundedSemaphore(Semaphore):
    def __init__(self, value=1):
        pass
    def release(self, n=1):
        pass
class Event:
    def __init__(self):
        pass
    def _at_fork_reinit(self):
        pass
    def is_set(self):
        pass
    def set(self):
        pass
    def clear(self):
        pass
    def wait(self, timeout=None):
        pass
class Barrier:
    def __init__(self, parties, action=None, timeout=None):
        pass
    def wait(self, timeout=None):
        pass
    def _enter(self):
        pass
    def _release(self):
        pass
    def _wait(self, timeout):
        pass
    def _exit(self):
        pass
    def reset(self):
        pass
    def abort(self):
        pass
    def _break(self):
        pass
    def parties(self):
        pass
    def n_waiting(self):
        pass
    def broken(self):
        pass
class BrokenBarrierError(RuntimeError):
def _newname(template="Thread-%d"):
   pass
class Thread:
    def _reset_internal_locks(self, is_alive):
        pass
    def __repr__(self):
        pass
    def start(self):
        pass
    def run(self):
        pass
    def _bootstrap(self):
        pass
    def _set_ident(self):
        pass
        def _set_native_id(self):
                pass
    def _set_tstate_lock(self):
        pass
    def _bootstrap_inner(self):
        pass
    def _stop(self):
        pass
    def _delete(self):
        pass
    def join(self, timeout=None):
        pass
    def _wait_for_tstate_lock(self, block=True, timeout=-1):
        pass
    def name(self):
        pass
    def name(self, name):
        pass
    def ident(self):
        pass
        def native_id(self):
                pass
    def is_alive(self):
        pass
    def daemon(self):
        pass
    def daemon(self, daemonic):
        pass
    def isDaemon(self):
        pass
    def setDaemon(self, daemonic):
        pass
    def getName(self):
        pass
    def setName(self, name):
        pass
    def ExceptHookArgs(args):
        pass
    def excepthook(args, /):
        pass
def _make_invoke_excepthook():
   pass
    def invoke_excepthook(thread):
        pass
class Timer(Thread):
    def __init__(self, interval, function, args=None, kwargs=None):
        pass
    def cancel(self):
        pass
    def run(self):
        pass
class _MainThread(Thread):
    def __init__(self):
        pass
class _DummyThread(Thread):
    def __init__(self):
        pass
    def _stop(self):
        pass
    def is_alive(self):
        pass
    def join(self, timeout=None):
        pass
def current_thread():
   pass
def active_count():
   pass
def _enumerate():
   pass
def enumerate():
   pass
def _register_atexit(func, *arg, **kwargs):
   pass
def _shutdown():
   pass
def main_thread():
   pass
def _after_fork():
   pass
"""# timeit.py #"""
def inner(_it, _timer{init}):
   pass
def reindent(src, indent):
   pass
class Timer:
    def print_exc(self, file=None):
        pass
    def timeit(self, number=default_number):
        pass
    def repeat(self, repeat=default_repeat, number=default_number):
        pass
    def autorange(self, callback=None):
        pass
def main(args=None, *, _wrap_timer=None):
   pass
            def callback(number, time_taken):
                        pass
    def format_time(dt):
        pass
"""# token.py #"""
def ISTERMINAL(x):
   pass
def ISNONTERMINAL(x):
   pass
def ISEOF(x):
   pass
"""# tokenize.py #"""
class TokenInfo(collections.namedtuple('TokenInfo', 'type string start end line')):
    def __repr__(self):
        pass
    def exact_type(self):
        pass
def group(*choices): return '(' + '|'.join(choices) + ')'
   pass
def any(*choices): return group(*choices) + '*'
   pass
def maybe(*choices): return group(*choices) + '?'
   pass
def _all_string_prefixes():
   pass
def _compile(expr):
   pass
class TokenError(Exception): pass
class StopTokenizing(Exception): pass
class Untokenizer:
    def __init__(self):
        pass
    def add_whitespace(self, start):
        pass
    def untokenize(self, iterable):
        pass
    def compat(self, token, iterable):
        pass
def untokenize(iterable):
   pass
def _get_normal_name(orig_enc):
   pass
def detect_encoding(readline):
   pass
    def read_or_stop():
        pass
    def find_cookie(line):
        pass
def open(filename):
   pass
def tokenize(readline):
   pass
def _tokenize(readline, encoding):
   pass
def generate_tokens(readline):
   pass
def main():
   pass
    def perror(message):
        pass
    def error(message, filename=None, location=None):
        pass
"""# trace.py #"""
class _Ignore:
    def __init__(self, modules=None, dirs=None):
        pass
    def names(self, filename, modulename):
        pass
def _modname(path):
   pass
def _fullmodname(path):
   pass
class CoverageResults:
    def is_ignored_filename(self, filename):
        pass
    def update(self, other):
        pass
    def write_results(self, show_missing=True, summary=False, coverdir=None):
        pass
    def write_results_file(self, path, lines, lnotab, lines_hit, encoding=None):
        pass
def _find_lines_from_code(code, strs):
   pass
def _find_lines(code, strs):
   pass
def _find_strings(filename, encoding=None):
   pass
def _find_executable_linenos(filename):
   pass
class Trace:
    def run(self, cmd):
        pass
    def runctx(self, cmd, globals=None, locals=None):
        pass
    def runfunc(self, func, /, *args, **kw):
        pass
    def file_module_function_of(self, frame):
        pass
    def globaltrace_trackcallers(self, frame, why, arg):
        pass
    def globaltrace_countfuncs(self, frame, why, arg):
        pass
    def globaltrace_lt(self, frame, why, arg):
        pass
    def localtrace_trace_and_count(self, frame, why, arg):
        pass
    def localtrace_trace(self, frame, why, arg):
        pass
    def localtrace_count(self, frame, why, arg):
        pass
    def results(self):
        pass
def main():
   pass
    def parse_ignore_dir(s):
        pass
"""# traceback.py #"""
def print_list(extracted_list, file=None):
   pass
def format_list(extracted_list):
   pass
def print_tb(tb, limit=None, file=None):
   pass
def format_tb(tb, limit=None):
   pass
def extract_tb(tb, limit=None):
   pass
def print_exception(etype, value, tb, limit=None, file=None, chain=True):
   pass
def format_exception(etype, value, tb, limit=None, chain=True):
   pass
def format_exception_only(etype, value):
   pass
def _format_final_exc_line(etype, value):
   pass
def _some_str(value):
   pass
def print_exc(limit=None, file=None, chain=True):
   pass
def format_exc(limit=None, chain=True):
   pass
def print_last(limit=None, file=None, chain=True):
   pass
def print_stack(f=None, limit=None, file=None):
   pass
def format_stack(f=None, limit=None):
   pass
def extract_stack(f=None, limit=None):
   pass
def clear_frames(tb):
   pass
class FrameSummary:
    def __eq__(self, other):
        pass
    def __getitem__(self, pos):
        pass
    def __iter__(self):
        pass
    def __repr__(self):
        pass
    def __len__(self):
        pass
    def line(self):
        pass
def walk_stack(f):
   pass
def walk_tb(tb):
   pass
class StackSummary(list):
    def from_list(klass, a_list):
        pass
    def format(self):
        pass
class TracebackException:
    def from_exception(cls, exc, *args, **kwargs):
        pass
    def _load_lines(self):
        pass
    def __eq__(self, other):
        pass
    def __str__(self):
        pass
    def format_exception_only(self):
        pass
    def _format_syntax_error(self, stype):
        pass
    def format(self, *, chain=True):
        pass
"""# tracemalloc.py #"""
def _format_size(size, sign):
   pass
class Statistic:
    def __init__(self, traceback, size, count):
        pass
    def __hash__(self):
        pass
    def __eq__(self, other):
        pass
    def __str__(self):
        pass
    def __repr__(self):
        pass
    def _sort_key(self):
        pass
class StatisticDiff:
    def __init__(self, traceback, size, size_diff, count, count_diff):
        pass
    def __hash__(self):
        pass
    def __eq__(self, other):
        pass
    def __str__(self):
        pass
    def __repr__(self):
        pass
    def _sort_key(self):
        pass
def _compare_grouped_stats(old_group, new_group):
   pass
class Frame:
    def __init__(self, frame):
        pass
    def filename(self):
        pass
    def lineno(self):
        pass
    def __eq__(self, other):
        pass
    def __lt__(self, other):
        pass
    def __hash__(self):
        pass
    def __str__(self):
        pass
    def __repr__(self):
        pass
class Traceback(Sequence):
    def __init__(self, frames, total_nframe=None):
        pass
    def total_nframe(self):
        pass
    def __len__(self):
        pass
    def __getitem__(self, index):
        pass
    def __contains__(self, frame):
        pass
    def __hash__(self):
        pass
    def __eq__(self, other):
        pass
    def __lt__(self, other):
        pass
    def __str__(self):
        pass
    def __repr__(self):
        pass
    def format(self, limit=None, most_recent_first=False):
        pass
def get_object_traceback(obj):
   pass
class Trace:
    def __init__(self, trace):
        pass
    def domain(self):
        pass
    def size(self):
        pass
    def traceback(self):
        pass
    def __eq__(self, other):
        pass
    def __hash__(self):
        pass
    def __str__(self):
        pass
    def __repr__(self):
        pass
class _Traces(Sequence):
    def __init__(self, traces):
        pass
    def __len__(self):
        pass
    def __getitem__(self, index):
        pass
    def __contains__(self, trace):
        pass
    def __eq__(self, other):
        pass
    def __repr__(self):
        pass
def _normalize_filename(filename):
   pass
class BaseFilter:
    def __init__(self, inclusive):
        pass
    def _match(self, trace):
        pass
class Filter(BaseFilter):
    def filename_pattern(self):
        pass
    def _match_frame_impl(self, filename, lineno):
        pass
    def _match_frame(self, filename, lineno):
        pass
    def _match_traceback(self, traceback):
        pass
    def _match(self, trace):
        pass
class DomainFilter(BaseFilter):
    def __init__(self, inclusive, domain):
        pass
    def domain(self):
        pass
    def _match(self, trace):
        pass
class Snapshot:
    def __init__(self, traces, traceback_limit):
        pass
    def dump(self, filename):
        pass
    def load(filename):
        pass
    def _filter_trace(self, include_filters, exclude_filters, trace):
        pass
    def filter_traces(self, filters):
        pass
    def _group_by(self, key_type, cumulative):
        pass
    def statistics(self, key_type, cumulative=False):
        pass
    def compare_to(self, old_snapshot, key_type, cumulative=False):
        pass
def take_snapshot():
   pass
"""# tty.py #"""
def setraw(fd, when=TCSAFLUSH):
   pass
def setcbreak(fd, when=TCSAFLUSH):
   pass
"""# turtle.py #"""
def config_dict(filename):
   pass
def readconfig(cfgdict):
   pass
    def __new__(cls, x, y):
        pass
    def __add__(self, other):
        pass
    def __mul__(self, other):
        pass
    def __rmul__(self, other):
        pass
    def __sub__(self, other):
        pass
    def __neg__(self):
        pass
    def __abs__(self):
        pass
    def rotate(self, angle):
        pass
    def __getnewargs__(self):
        pass
    def __repr__(self):
        pass
def __methodDict(cls, _dict):
   pass
def __methods(cls):
   pass
def __forwardmethods(fromClass, toClass, toPart, exclude = ()):
   pass
class ScrolledCanvas(TK.Frame):
    def reset(self, canvwidth=None, canvheight=None, bg = None):
        pass
    def adjustScrolls(self):
        pass
    def onResize(self, event):
        pass
    def bbox(self, *args):
        pass
    def cget(self, *args, **kwargs):
        pass
    def config(self, *args, **kwargs):
        pass
    def bind(self, *args, **kwargs):
        pass
    def unbind(self, *args, **kwargs):
        pass
    def focus_force(self):
        pass
class _Root(TK.Tk):
    def __init__(self):
        pass
    def setupcanvas(self, width, height, cwidth, cheight):
        pass
    def _getcanvas(self):
        pass
    def set_geometry(self, width, height, startx, starty):
        pass
    def ondestroy(self, destroy):
        pass
    def win_width(self):
        pass
    def win_height(self):
        pass
class TurtleScreenBase(object):
    def _blankimage():
        pass
    def _image(filename):
        pass
    def __init__(self, cv):
        pass
    def _createpoly(self):
        pass
    def _createline(self):
        pass
    def _delete(self, item):
        pass
    def _update(self):
        pass
    def _delay(self, delay):
        pass
    def _iscolorstring(self, color):
        pass
    def _bgcolor(self, color=None):
        pass
    def _write(self, pos, txt, align, font, pencolor):
        pass
    def _onclick(self, item, fun, num=1, add=None):
        pass
            def eventfun(event):
                        pass
    def _onrelease(self, item, fun, num=1, add=None):
        pass
            def eventfun(event):
                        pass
    def _ondrag(self, item, fun, num=1, add=None):
        pass
            def eventfun(event):
                        pass
    def _onscreenclick(self, fun, num=1, add=None):
        pass
            def eventfun(event):
                        pass
    def _onkeyrelease(self, fun, key):
        pass
            def eventfun(event):
                        pass
    def _onkeypress(self, fun, key=None):
        pass
            def eventfun(event):
                        pass
    def _listen(self):
        pass
    def _ontimer(self, fun, t):
        pass
    def _createimage(self, image):
        pass
    def _drawimage(self, item, pos, image):
        pass
    def _setbgpic(self, item, image):
        pass
    def _type(self, item):
        pass
    def _pointlist(self, item):
        pass
    def _setscrollregion(self, srx1, sry1, srx2, sry2):
        pass
    def _rescale(self, xscalefactor, yscalefactor):
        pass
    def _resize(self, canvwidth=None, canvheight=None, bg=None):
        pass
    def _window_size(self):
        pass
    def mainloop(self):
        pass
    def textinput(self, title, prompt):
        pass
    def numinput(self, title, prompt, default=None, minval=None, maxval=None):
        pass
class Terminator (Exception):
class TurtleGraphicsError(Exception):
class Shape(object):
    def __init__(self, type_, data=None):
        pass
    def addcomponent(self, poly, fill, outline=None):
        pass
class Tbuffer(object):
    def __init__(self, bufsize=10):
        pass
    def reset(self, bufsize=None):
        pass
    def push(self, item):
        pass
    def pop(self):
        pass
    def nr_of_items(self):
        pass
    def __repr__(self):
        pass
class TurtleScreen(TurtleScreenBase):
    def clear(self):
        pass
    def mode(self, mode=None):
        pass
    def setworldcoordinates(self, llx, lly, urx, ury):
        pass
    def register_shape(self, name, shape=None):
        pass
    def _colorstr(self, color):
        pass
    def _color(self, cstr):
        pass
    def colormode(self, cmode=None):
        pass
    def reset(self):
        pass
    def turtles(self):
        pass
    def bgcolor(self, *args):
        pass
    def tracer(self, n=None, delay=None):
        pass
    def delay(self, delay=None):
        pass
    def _incrementudc(self):
        pass
    def update(self):
        pass
    def window_width(self):
        pass
    def window_height(self):
        pass
    def getcanvas(self):
        pass
    def getshapes(self):
        pass
    def onclick(self, fun, btn=1, add=None):
        pass
    def onkey(self, fun, key):
        pass
    def onkeypress(self, fun, key=None):
        pass
    def listen(self, xdummy=None, ydummy=None):
        pass
    def ontimer(self, fun, t=0):
        pass
    def bgpic(self, picname=None):
        pass
    def screensize(self, canvwidth=None, canvheight=None, bg=None):
        pass
class TNavigator(object):
    def __init__(self, mode=DEFAULT_MODE):
        pass
    def reset(self):
        pass
    def _setmode(self, mode=None):
        pass
    def _setDegreesPerAU(self, fullcircle):
        pass
    def degrees(self, fullcircle=360.0):
        pass
    def radians(self):
        pass
    def _go(self, distance):
        pass
    def _rotate(self, angle):
        pass
    def _goto(self, end):
        pass
    def forward(self, distance):
        pass
    def back(self, distance):
        pass
    def right(self, angle):
        pass
    def left(self, angle):
        pass
    def pos(self):
        pass
    def xcor(self):
        pass
    def ycor(self):
        pass
    def goto(self, x, y=None):
        pass
    def home(self):
        pass
    def setx(self, x):
        pass
    def sety(self, y):
        pass
    def distance(self, x, y=None):
        pass
    def towards(self, x, y=None):
        pass
    def heading(self):
        pass
    def setheading(self, to_angle):
        pass
    def circle(self, radius, extent = None, steps = None):
        pass
    def speed(self, s=0):
        pass
    def _tracer(self, a=None, b=None):
        pass
    def _delay(self, n=None):
        pass
class TPen(object):
    def __init__(self, resizemode=_CFG["resizemode"]):
        pass
    def resizemode(self, rmode=None):
        pass
    def pensize(self, width=None):
        pass
    def penup(self):
        pass
    def pendown(self):
        pass
    def isdown(self):
        pass
    def speed(self, speed=None):
        pass
    def color(self, *args):
        pass
    def pencolor(self, *args):
        pass
    def fillcolor(self, *args):
        pass
    def showturtle(self):
        pass
    def hideturtle(self):
        pass
    def isvisible(self):
        pass
    def pen(self, pen=None, **pendict):
        pass
    def _newLine(self, usePos = True):
        pass
    def _update(self, count=True, forced=False):
        pass
    def _color(self, args):
        pass
    def _colorstr(self, args):
        pass
class _TurtleImage(object):
    def __init__(self, screen, shapeIndex):
        pass
    def _setshape(self, shapeIndex):
        pass
class RawTurtle(TPen, TNavigator):
    def reset(self):
        pass
    def setundobuffer(self, size):
        pass
    def undobufferentries(self):
        pass
    def _clear(self):
        pass
    def clear(self):
        pass
    def _update_data(self):
        pass
    def _update(self):
        pass
    def _tracer(self, flag=None, delay=None):
        pass
    def _color(self, args):
        pass
    def _colorstr(self, args):
        pass
    def _cc(self, args):
        pass
    def clone(self):
        pass
    def shape(self, name=None):
        pass
    def shapesize(self, stretch_wid=None, stretch_len=None, outline=None):
        pass
    def shearfactor(self, shear=None):
        pass
    def settiltangle(self, angle):
        pass
    def tiltangle(self, angle=None):
        pass
    def tilt(self, angle):
        pass
    def shapetransform(self, t11=None, t12=None, t21=None, t22=None):
        pass
    def _polytrafo(self, poly):
        pass
    def get_shapepoly(self):
        pass
    def _getshapepoly(self, polygon, compound=False):
        pass
    def _drawturtle(self):
        pass
    def stamp(self):
        pass
    def _clearstamp(self, stampid):
        pass
    def clearstamp(self, stampid):
        pass
    def clearstamps(self, n=None):
        pass
    def _goto(self, end):
        pass
    def _undogoto(self, entry):
        pass
    def _rotate(self, angle):
        pass
    def _newLine(self, usePos=True):
        pass
    def filling(self):
        pass
    def begin_fill(self):
        pass
    def end_fill(self):
        pass
    def dot(self, size=None, *color):
        pass
    def _write(self, txt, align, font):
        pass
    def write(self, arg, move=False, align="left", font=("Arial", 8, "normal")):
        pass
    def begin_poly(self):
        pass
    def end_poly(self):
        pass
    def get_poly(self):
        pass
    def getscreen(self):
        pass
    def getturtle(self):
        pass
    def _delay(self, delay=None):
        pass
    def onclick(self, fun, btn=1, add=None):
        pass
    def onrelease(self, fun, btn=1, add=None):
        pass
    def ondrag(self, fun, btn=1, add=None):
        pass
    def _undo(self, action, data):
        pass
    def undo(self):
        pass
def Screen():
   pass
class _Screen(TurtleScreen):
    def __init__(self):
        pass
    def title(self, titlestring):
        pass
    def _destroy(self):
        pass
    def bye(self):
        pass
    def exitonclick(self):
        pass
        def exitGracefully(x, y):
                pass
class Turtle(RawTurtle):
def write_docstringdict(filename="turtle_docstringdict"):
   pass
def read_docstrings(lang):
   pass
def getmethparlist(ob):
   pass
def _turtle_docrevise(docstr):
   pass
def _screen_docrevise(docstr):
   pass
def _make_global_funcs(functions, cls, obj, init, docrevise):
   pass
    def switchpen():
        pass
        def baba(xdummy, ydummy):
                pass
"""# types.py #"""
def _f(): pass
   pass
def _cell_factory():
   pass
    def f():
        pass
def _g():
   pass
class _C:
    def _m(self): pass
        pass
def new_class(name, bases=(), kwds=None, exec_body=None):
   pass
def resolve_bases(bases):
   pass
def prepare_class(name, bases=(), kwds=None):
   pass
def _calculate_meta(meta, bases):
   pass
class DynamicClassAttribute:
    def __init__(self, fget=None, fset=None, fdel=None, doc=None):
        pass
    def __get__(self, instance, ownerclass=None):
        pass
    def __set__(self, instance, value):
        pass
    def __delete__(self, instance):
        pass
    def getter(self, fget):
        pass
    def setter(self, fset):
        pass
    def deleter(self, fdel):
        pass
class _GeneratorWrapper:
    def __init__(self, gen):
        pass
    def send(self, val):
        pass
    def throw(self, tp, *rest):
        pass
    def close(self):
        pass
    def gi_code(self):
        pass
    def gi_frame(self):
        pass
    def gi_running(self):
        pass
    def gi_yieldfrom(self):
        pass
    def __next__(self):
        pass
    def __iter__(self):
        pass
def coroutine(func):
   pass
    def wrapped(*args, **kwargs):
        pass
"""# typing.py #"""
def _type_check(arg, msg, is_argument=True):
   pass
def _type_repr(obj):
   pass
def _collect_type_vars(types):
   pass
def _check_generic(cls, parameters, elen):
   pass
def _deduplicate(params):
   pass
def _remove_dups_flatten(parameters):
   pass
def _flatten_literal_params(parameters):
   pass
def _tp_cache(func=None, /, *, typed=False):
   pass
    def decorator(func):
        pass
        def inner(*args, **kwds):
                pass
def _eval_type(t, globalns, localns, recursive_guard=frozenset()):
   pass
class _Final:
    def __init_subclass__(self, /, *args, **kwds):
        pass
class _Immutable:
    def __copy__(self):
        pass
    def __deepcopy__(self, memo):
        pass
class _SpecialForm(_Final, _root=True):
    def __init__(self, getitem):
        pass
    def __mro_entries__(self, bases):
        pass
    def __repr__(self):
        pass
    def __reduce__(self):
        pass
    def __call__(self, *args, **kwds):
        pass
    def __instancecheck__(self, obj):
        pass
    def __subclasscheck__(self, cls):
        pass
    def __getitem__(self, parameters):
        pass
class _LiteralSpecialForm(_SpecialForm, _root=True):
    def __getitem__(self, parameters):
        pass
def Any(self, parameters):
   pass
def NoReturn(self, parameters):
   pass
def ClassVar(self, parameters):
   pass
      class Starship:
def Final(self, parameters):
   pass
      class Connection:
      class FastConnector(Connection):
def Union(self, parameters):
   pass
def Optional(self, parameters):
   pass
def Literal(self, parameters):
   pass
class ForwardRef(_Final, _root=True):
    def __init__(self, arg, is_argument=True):
        pass
    def _evaluate(self, globalns, localns, recursive_guard):
        pass
    def __eq__(self, other):
        pass
    def __hash__(self):
        pass
    def __repr__(self):
        pass
class TypeVar(_Final, _Immutable, _root=True):
    def __repr__(self):
        pass
    def __reduce__(self):
        pass
def _is_dunder(attr):
   pass
class _BaseGenericAlias(_Final, _root=True):
    def __init__(self, origin, *, inst=True, name=None):
        pass
    def __call__(self, *args, **kwargs):
        pass
    def __mro_entries__(self, bases):
        pass
    def __getattr__(self, attr):
        pass
    def __setattr__(self, attr, val):
        pass
    def __instancecheck__(self, obj):
        pass
    def __subclasscheck__(self, cls):
        pass
class _GenericAlias(_BaseGenericAlias, _root=True):
    def __init__(self, origin, params, *, inst=True, name=None):
        pass
    def __eq__(self, other):
        pass
    def __hash__(self):
        pass
    def __getitem__(self, params):
        pass
    def copy_with(self, params):
        pass
    def __repr__(self):
        pass
    def __reduce__(self):
        pass
    def __mro_entries__(self, bases):
        pass
class _SpecialGenericAlias(_BaseGenericAlias, _root=True):
    def __init__(self, origin, nparams, *, inst=True, name=None):
        pass
    def __getitem__(self, params):
        pass
    def copy_with(self, params):
        pass
    def __repr__(self):
        pass
    def __subclasscheck__(self, cls):
        pass
    def __reduce__(self):
        pass
class _CallableGenericAlias(_GenericAlias, _root=True):
    def __repr__(self):
        pass
    def __reduce__(self):
        pass
class _CallableType(_SpecialGenericAlias, _root=True):
    def copy_with(self, params):
        pass
    def __getitem__(self, params):
        pass
    def __getitem_inner__(self, params):
        pass
class _TupleType(_SpecialGenericAlias, _root=True):
    def __getitem__(self, params):
        pass
class _UnionGenericAlias(_GenericAlias, _root=True):
    def copy_with(self, params):
        pass
    def __eq__(self, other):
        pass
    def __hash__(self):
        pass
    def __repr__(self):
        pass
def _value_and_type_iter(parameters):
   pass
class _LiteralGenericAlias(_GenericAlias, _root=True):
    def __eq__(self, other):
        pass
    def __hash__(self):
        pass
class Generic:
      class Mapping(Generic[KT, VT]):
    def __class_getitem__(cls, params):
        pass
    def __init_subclass__(cls, *args, **kwargs):
        pass
class _TypingEmpty:
class _TypingEllipsis:
def _get_protocol_attrs(cls):
   pass
def _is_callable_members_only(cls):
   pass
def _no_init(self, *args, **kwargs):
   pass
def _allow_reckless_class_cheks():
   pass
class _ProtocolMeta(ABCMeta):
    def __instancecheck__(cls, instance):
        pass
class Protocol(Generic, metaclass=_ProtocolMeta):
        class Proto(Protocol):
        class C:
        class GenProto(Protocol[T]):
    def __init_subclass__(cls, *args, **kwargs):
        pass
        def _proto_hook(other):
                pass
class _AnnotatedAlias(_GenericAlias, _root=True):
    def __init__(self, origin, metadata):
        pass
    def copy_with(self, params):
        pass
    def __repr__(self):
        pass
    def __reduce__(self):
        pass
    def __eq__(self, other):
        pass
    def __hash__(self):
        pass
class Annotated:
    def __new__(cls, *args, **kwargs):
        pass
    def __class_getitem__(cls, params):
        pass
    def __init_subclass__(cls, *args, **kwargs):
        pass
def runtime_checkable(cls):
   pass
        class Closable(Protocol):
            def close(self): ...
                        pass
def cast(typ, val):
   pass
def _get_defaults(func):
   pass
def get_type_hints(obj, globalns=None, localns=None, include_extras=False):
   pass
def _strip_annotations(t):
   pass
def get_origin(tp):
   pass
def get_args(tp):
   pass
def no_type_check(arg):
   pass
def no_type_check_decorator(decorator):
   pass
    def wrapped_decorator(*args, **kwds):
        pass
def _overload_dummy(*args, **kwds):
   pass
def overload(func):
   pass
def final(f):
   pass
      class Base:
      class Sub(Base):
      class Leaf:
      class Other(Leaf):  # Error reported by type checker
      class User: ...  # Abstract base for User classes
      class BasicUser(User): ...
      class ProUser(User): ...
      class TeamUser(User): ...
class SupportsInt(Protocol):
class SupportsFloat(Protocol):
class SupportsComplex(Protocol):
class SupportsBytes(Protocol):
class SupportsIndex(Protocol):
class SupportsAbs(Protocol[T_co]):
class SupportsRound(Protocol[T_co]):
def _make_nmtuple(name, types, module, defaults = ()):
   pass
class NamedTupleMeta(type):
    def __new__(cls, typename, bases, ns):
        pass
def NamedTuple(typename, fields=None, /, **kwargs):
   pass
        class Employee(NamedTuple):
def _namedtuple_mro_entries(bases):
   pass
class _TypedDictMeta(type):
    def __new__(cls, name, bases, ns, total=True):
        pass
    def __subclasscheck__(cls, other):
        pass
def TypedDict(typename, fields=None, /, *, total=True, **kwargs):
   pass
def NewType(name, tp):
   pass
    def new_type(x):
        pass
class IO(Generic[AnyStr]):
class BinaryIO(IO[bytes]):
class TextIO(IO[str]):
class io:
class re:
"""# uu.py #"""
class Error(Exception):
def encode(in_file, out_file, name=None, mode=None, *, backtick=False):
   pass
def decode(in_file, out_file=None, mode=None, quiet=False):
   pass
def test():
   pass
"""# uuid.py #"""
class SafeUUID(Enum):
class UUID:
    def __getstate__(self):
        pass
    def __setstate__(self, state):
        pass
    def __eq__(self, other):
        pass
    def __lt__(self, other):
        pass
    def __gt__(self, other):
        pass
    def __le__(self, other):
        pass
    def __ge__(self, other):
        pass
    def __hash__(self):
        pass
    def __int__(self):
        pass
    def __repr__(self):
        pass
    def __setattr__(self, name, value):
        pass
    def __str__(self):
        pass
    def bytes(self):
        pass
    def bytes_le(self):
        pass
    def fields(self):
        pass
    def time_low(self):
        pass
    def time_mid(self):
        pass
    def time_hi_version(self):
        pass
    def clock_seq_hi_variant(self):
        pass
    def clock_seq_low(self):
        pass
    def time(self):
        pass
    def clock_seq(self):
        pass
    def node(self):
        pass
    def hex(self):
        pass
    def urn(self):
        pass
    def variant(self):
        pass
    def version(self):
        pass
def _get_command_stdout(command, *args):
   pass
def _is_universal(mac):
   pass
def _find_mac_near_keyword(command, args, keywords, get_word_index):
   pass
def _parse_mac(word):
   pass
def _find_mac_under_heading(command, args, heading):
   pass
def _ifconfig_getnode():
   pass
def _ip_getnode():
   pass
def _arp_getnode():
   pass
def _lanscan_getnode():
   pass
def _netstat_getnode():
   pass
def _ipconfig_getnode():
   pass
def _netbios_getnode():
   pass
def _load_system_functions():
   pass
def _unix_getnode():
   pass
def _windll_getnode():
   pass
def _random_getnode():
   pass
def getnode():
   pass
"""# warnings.py #"""
def showwarning(message, category, filename, lineno, file=None, line=None):
   pass
def formatwarning(message, category, filename, lineno, line=None):
   pass
def _showwarnmsg_impl(msg):
   pass
def _formatwarnmsg_impl(msg):
   pass
def _showwarnmsg(msg):
   pass
def _formatwarnmsg(msg):
   pass
def simplefilter(action, category=Warning, lineno=0, append=False):
   pass
def _add_filter(*item, append):
   pass
def resetwarnings():
   pass
class _OptionError(Exception):
def _processoptions(args):
   pass
def _setoption(arg):
   pass
def _getaction(action):
   pass
def _getcategory(category):
   pass
def _is_internal_frame(frame):
   pass
def _next_external_frame(frame):
   pass
def warn(message, category=None, stacklevel=1, source=None):
   pass
class WarningMessage(object):
    def __str__(self):
        pass
class catch_warnings(object):
    def __init__(self, *, record=False, module=None):
        pass
    def __repr__(self):
        pass
    def __enter__(self):
        pass
    def __exit__(self, *exc_info):
        pass
def _warn_unawaited_coroutine(coro):
   pass
        def extract():
                pass
    def _filters_mutated():
        pass
"""# wave.py #"""
class Error(Exception):
class Wave_read:
    def initfp(self, file):
        pass
    def __init__(self, f):
        pass
    def __del__(self):
        pass
    def __enter__(self):
        pass
    def __exit__(self, *args):
        pass
    def getfp(self):
        pass
    def rewind(self):
        pass
    def close(self):
        pass
    def tell(self):
        pass
    def getnchannels(self):
        pass
    def getnframes(self):
        pass
    def getsampwidth(self):
        pass
    def getframerate(self):
        pass
    def getcomptype(self):
        pass
    def getcompname(self):
        pass
    def getparams(self):
        pass
    def getmarkers(self):
        pass
    def getmark(self, id):
        pass
    def setpos(self, pos):
        pass
    def readframes(self, nframes):
        pass
    def _read_fmt_chunk(self, chunk):
        pass
class Wave_write:
    def __init__(self, f):
        pass
    def initfp(self, file):
        pass
    def __del__(self):
        pass
    def __enter__(self):
        pass
    def __exit__(self, *args):
        pass
    def setnchannels(self, nchannels):
        pass
    def getnchannels(self):
        pass
    def setsampwidth(self, sampwidth):
        pass
    def getsampwidth(self):
        pass
    def setframerate(self, framerate):
        pass
    def getframerate(self):
        pass
    def setnframes(self, nframes):
        pass
    def getnframes(self):
        pass
    def setcomptype(self, comptype, compname):
        pass
    def getcomptype(self):
        pass
    def getcompname(self):
        pass
    def setparams(self, params):
        pass
    def getparams(self):
        pass
    def setmark(self, id, pos, name):
        pass
    def getmark(self, id):
        pass
    def getmarkers(self):
        pass
    def tell(self):
        pass
    def writeframesraw(self, data):
        pass
    def writeframes(self, data):
        pass
    def close(self):
        pass
    def _ensure_header_written(self, datasize):
        pass
    def _write_header(self, initlength):
        pass
    def _patchheader(self):
        pass
def open(f, mode=None):
   pass
"""# weakref.py #"""
class WeakMethod(ref):
    def __new__(cls, meth, callback=None):
        pass
        def _cb(arg):
                pass
    def __call__(self):
        pass
    def __eq__(self, other):
        pass
    def __ne__(self, other):
        pass
class WeakValueDictionary(_collections_abc.MutableMapping):
    def __init__(self, other=(), /, **kw):
        pass
        def remove(wr, selfref=ref(self), _atomic_removal=_remove_dead_weakref):
                pass
    def _commit_removals(self):
        pass
    def __getitem__(self, key):
        pass
    def __delitem__(self, key):
        pass
    def __len__(self):
        pass
    def __contains__(self, key):
        pass
    def __repr__(self):
        pass
    def __setitem__(self, key, value):
        pass
    def copy(self):
        pass
    def __deepcopy__(self, memo):
        pass
    def get(self, key, default=None):
        pass
    def items(self):
        pass
    def keys(self):
        pass
    def itervaluerefs(self):
        pass
    def values(self):
        pass
    def popitem(self):
        pass
    def pop(self, key, *args):
        pass
    def setdefault(self, key, default=None):
        pass
    def update(self, other=None, /, **kwargs):
        pass
    def valuerefs(self):
        pass
    def __ior__(self, other):
        pass
    def __or__(self, other):
        pass
    def __ror__(self, other):
        pass
class KeyedRef(ref):
    def __new__(type, ob, callback, key):
        pass
    def __init__(self, ob, callback, key):
        pass
class WeakKeyDictionary(_collections_abc.MutableMapping):
    def __init__(self, dict=None):
        pass
        def remove(k, selfref=ref(self)):
                pass
    def _commit_removals(self):
        pass
    def _scrub_removals(self):
        pass
    def __delitem__(self, key):
        pass
    def __getitem__(self, key):
        pass
    def __len__(self):
        pass
    def __repr__(self):
        pass
    def __setitem__(self, key, value):
        pass
    def copy(self):
        pass
    def __deepcopy__(self, memo):
        pass
    def get(self, key, default=None):
        pass
    def __contains__(self, key):
        pass
    def items(self):
        pass
    def keys(self):
        pass
    def values(self):
        pass
    def keyrefs(self):
        pass
    def popitem(self):
        pass
    def pop(self, key, *args):
        pass
    def setdefault(self, key, default=None):
        pass
    def update(self, dict=None, /, **kwargs):
        pass
    def __ior__(self, other):
        pass
    def __or__(self, other):
        pass
    def __ror__(self, other):
        pass
class finalize:
    class _Info:
    def __init__(self, obj, func, /, *args, **kwargs):
        pass
    def __call__(self, _=None):
        pass
    def detach(self):
        pass
    def peek(self):
        pass
    def alive(self):
        pass
    def atexit(self):
        pass
    def atexit(self, value):
        pass
    def __repr__(self):
        pass
    def _select_for_exit(cls):
        pass
    def _exitfunc(cls):
        pass
"""# webbrowser.py #"""
class Error(Exception):
def register(name, klass, instance=None, *, preferred=False):
   pass
def get(using=None):
   pass
def open(url, new=0, autoraise=True):
   pass
def open_new(url):
   pass
def open_new_tab(url):
   pass
def _synthesize(browser, *, preferred=False):
   pass
class BaseBrowser(object):
    def __init__(self, name=""):
        pass
    def open(self, url, new=0, autoraise=True):
        pass
    def open_new(self, url):
        pass
    def open_new_tab(self, url):
        pass
class GenericBrowser(BaseBrowser):
    def __init__(self, name):
        pass
    def open(self, url, new=0, autoraise=True):
        pass
class BackgroundBrowser(GenericBrowser):
    def open(self, url, new=0, autoraise=True):
        pass
class UnixBrowser(BaseBrowser):
    def _invoke(self, args, remote, autoraise, url=None):
        pass
    def open(self, url, new=0, autoraise=True):
        pass
class Mozilla(UnixBrowser):
class Netscape(UnixBrowser):
class Galeon(UnixBrowser):
class Chrome(UnixBrowser):
class Opera(UnixBrowser):
class Elinks(UnixBrowser):
class Konqueror(BaseBrowser):
    def open(self, url, new=0, autoraise=True):
        pass
class Grail(BaseBrowser):
    def _find_grail_rc(self):
        pass
    def _remote(self, action):
        pass
    def open(self, url, new=0, autoraise=True):
        pass
def register_X_browsers():
   pass
def register_standard_browsers():
   pass
    class WindowsDefault(BaseBrowser):
        def open(self, url, new=0, autoraise=True):
                pass
    class MacOSX(BaseBrowser):
        def __init__(self, name):
                pass
        def open(self, url, new=0, autoraise=True):
                pass
    class MacOSXOSAScript(BaseBrowser):
        def __init__(self, name):
                pass
        def open(self, url, new=0, autoraise=True):
                pass
def main():
   pass
"""# xdrlib.py #"""
class Error(Exception):
    def __init__(self, msg):
        pass
    def __repr__(self):
        pass
    def __str__(self):
        pass
class ConversionError(Error):
def raise_conversion_error(function):
   pass
    def result(self, value):
        pass
class Packer:
    def __init__(self):
        pass
    def reset(self):
        pass
    def get_buffer(self):
        pass
    def pack_uint(self, x):
        pass
    def pack_int(self, x):
        pass
    def pack_bool(self, x):
        pass
    def pack_uhyper(self, x):
        pass
    def pack_float(self, x):
        pass
    def pack_double(self, x):
        pass
    def pack_fstring(self, n, s):
        pass
    def pack_string(self, s):
        pass
    def pack_list(self, list, pack_item):
        pass
    def pack_farray(self, n, list, pack_item):
        pass
    def pack_array(self, list, pack_item):
        pass
class Unpacker:
    def __init__(self, data):
        pass
    def reset(self, data):
        pass
    def get_position(self):
        pass
    def set_position(self, position):
        pass
    def get_buffer(self):
        pass
    def done(self):
        pass
    def unpack_uint(self):
        pass
    def unpack_int(self):
        pass
    def unpack_bool(self):
        pass
    def unpack_uhyper(self):
        pass
    def unpack_hyper(self):
        pass
    def unpack_float(self):
        pass
    def unpack_double(self):
        pass
    def unpack_fstring(self, n):
        pass
    def unpack_string(self):
        pass
    def unpack_list(self, unpack_item):
        pass
    def unpack_farray(self, n, unpack_item):
        pass
    def unpack_array(self, unpack_item):
        pass
"""# zipapp.py #"""
class ZipAppError(ValueError):
def _maybe_open(archive, mode):
   pass
def _write_file_prefix(f, interpreter):
   pass
def _copy_archive(archive, new_archive, interpreter=None):
   pass
def get_interpreter(archive):
   pass
def main(args=None):
   pass
"""# zipfile.py #"""
class BadZipFile(Exception):
class LargeZipFile(Exception):
def _strip_extra(extra, xids):
   pass
def _check_zipfile(fp):
   pass
def is_zipfile(filename):
   pass
def _EndRecData(fpin):
   pass
class ZipInfo (object):
    def __init__(self, filename="NoName", date_time=(1980,1,1,0,0,0)):
        pass
    def __repr__(self):
        pass
    def FileHeader(self, zip64=None):
        pass
    def _encodeFilenameFlags(self):
        pass
    def _decodeExtra(self):
        pass
    def from_file(cls, filename, arcname=None, *, strict_timestamps=True):
        pass
    def is_dir(self):
        pass
def _gen_crc(crc):
   pass
def _ZipDecrypter(pwd):
   pass
    def update_keys(c):
        pass
    def decrypter(data):
        pass
class LZMACompressor:
    def __init__(self):
        pass
    def _init(self):
        pass
    def compress(self, data):
        pass
    def flush(self):
        pass
class LZMADecompressor:
    def __init__(self):
        pass
    def decompress(self, data):
        pass
def _check_compression(compression):
   pass
def _get_compressor(compress_type, compresslevel=None):
   pass
def _get_decompressor(compress_type):
   pass
class _SharedFile:
    def __init__(self, file, pos, close, lock, writing):
        pass
    def seek(self, offset, whence=0):
        pass
    def read(self, n=-1):
        pass
    def close(self):
        pass
class _Tellable:
    def __init__(self, fp):
        pass
    def write(self, data):
        pass
    def tell(self):
        pass
    def flush(self):
        pass
    def close(self):
        pass
class ZipExtFile(io.BufferedIOBase):
    def _init_decrypter(self):
        pass
    def __repr__(self):
        pass
    def readline(self, limit=-1):
        pass
    def peek(self, n=1):
        pass
    def readable(self):
        pass
    def read(self, n=-1):
        pass
    def _update_crc(self, newdata):
        pass
    def close(self):
        pass
    def seekable(self):
        pass
    def seek(self, offset, whence=0):
        pass
    def tell(self):
        pass
class _ZipWriteFile(io.BufferedIOBase):
    def __init__(self, zf, zinfo, zip64):
        pass
    def _fileobj(self):
        pass
    def writable(self):
        pass
    def write(self, data):
        pass
    def close(self):
        pass
class ZipFile:
    def __enter__(self):
        pass
    def __exit__(self, type, value, traceback):
        pass
    def __repr__(self):
        pass
    def _RealGetContents(self):
        pass
    def namelist(self):
        pass
    def infolist(self):
        pass
    def printdir(self, file=None):
        pass
    def testzip(self):
        pass
    def getinfo(self, name):
        pass
    def setpassword(self, pwd):
        pass
    def comment(self):
        pass
    def comment(self, comment):
        pass
    def read(self, name, pwd=None):
        pass
    def open(self, name, mode="r", pwd=None, *, force_zip64=False):
        pass
    def _open_to_write(self, zinfo, force_zip64=False):
        pass
    def extract(self, member, path=None, pwd=None):
        pass
    def extractall(self, path=None, members=None, pwd=None):
        pass
    def _sanitize_windows_name(cls, arcname, pathsep):
        pass
    def _extract_member(self, member, targetpath, pwd):
        pass
    def _writecheck(self, zinfo):
        pass
    def __del__(self):
        pass
    def close(self):
        pass
    def _write_end_record(self):
        pass
    def _fpclose(self, fp):
        pass
class PyZipFile(ZipFile):
    def writepy(self, pathname, basename="", filterfunc=None):
        pass
    def _get_codename(self, pathname, basename):
        pass
        def _compile(file, optimize=-1):
                pass
def _parents(path):
   pass
def _ancestry(path):
   pass
def _difference(minuend, subtrahend):
   pass
class CompleteDirs(ZipFile):
    def _implied_dirs(names):
        pass
    def namelist(self):
        pass
    def _name_set(self):
        pass
    def resolve_dir(self, name):
        pass
    def make(cls, source):
        pass
class FastLookup(CompleteDirs):
    def namelist(self):
        pass
    def _name_set(self):
        pass
class Path:
    def __init__(self, root, at=""):
        pass
    def open(self, mode='r', *args, **kwargs):
        pass
    def name(self):
        pass
    def read_text(self, *args, **kwargs):
        pass
    def read_bytes(self):
        pass
    def _is_child(self, path):
        pass
    def _next(self, at):
        pass
    def is_dir(self):
        pass
    def is_file(self):
        pass
    def exists(self):
        pass
    def iterdir(self):
        pass
    def __str__(self):
        pass
    def __repr__(self):
        pass
    def joinpath(self, add):
        pass
    def parent(self):
        pass
def main(args=None):
   pass
        def addToZip(zf, path, zippath):
                pass
"""# zipimport.py #"""
class ZipImportError(ImportError):
class zipimporter:
    def __init__(self, path):
        pass
    def find_loader(self, fullname, path=None):
        pass
    def find_module(self, fullname, path=None):
        pass
    def get_code(self, fullname):
        pass
    def get_data(self, pathname):
        pass
    def get_filename(self, fullname):
        pass
    def get_source(self, fullname):
        pass
    def is_package(self, fullname):
        pass
    def load_module(self, fullname):
        pass
    def get_resource_reader(self, fullname):
        pass
    def __repr__(self):
        pass
def _get_module_path(self, fullname):
   pass
def _is_dir(self, path):
   pass
def _get_module_info(self, fullname):
   pass
def _read_directory(archive):
   pass
def _get_decompress_func():
   pass
def _get_data(archive, toc_entry):
   pass
def _eq_mtime(t1, t2):
   pass
def _unmarshal_code(self, pathname, fullpath, fullname, data):
   pass
def _normalize_line_endings(source):
   pass
def _compile_source(pathname, source):
   pass
def _parse_dostime(d, t):
   pass
def _get_mtime_and_size_of_source(self, path):
   pass
def _get_pyc_source(self, path):
   pass
def _get_module_code(self, fullname):
   pass
class _ZipImportResourceReader:
    def __init__(self, zipimporter, fullname):
        pass
    def open_resource(self, resource):
        pass
    def resource_path(self, resource):
        pass
    def is_resource(self, name):
        pass
    def contents(self):
        pass
"""# _aix_support.py #"""
def _aix_tag(vrtl, bd):
   pass
def _aix_vrtl(vrmf):
   pass
def aix_platform():
   pass
def _aix_bgt():
   pass
def aix_buildtag():
   pass
"""# _bootlocale.py #"""
    def getpreferredencoding(do_setlocale=True):
        pass
            def getpreferredencoding(do_setlocale=True):
                        pass
            def getpreferredencoding(do_setlocale=True):
                        pass
        def getpreferredencoding(do_setlocale=True):
                pass
"""# _bootsubprocess.py #"""
class Popen:
    def __init__(self, cmd, env=None):
        pass
    def wait(self):
        pass
def _check_cmd(cmd):
   pass
def check_output(cmd, **kwargs):
   pass
"""# _collections_abc.py #"""
def _check_methods(C, *methods):
   pass
class Hashable(metaclass=ABCMeta):
    def __hash__(self):
        pass
    def __subclasshook__(cls, C):
        pass
class Awaitable(metaclass=ABCMeta):
    def __await__(self):
        pass
    def __subclasshook__(cls, C):
        pass
class Coroutine(Awaitable):
    def send(self, value):
        pass
    def throw(self, typ, val=None, tb=None):
        pass
    def close(self):
        pass
    def __subclasshook__(cls, C):
        pass
class AsyncIterable(metaclass=ABCMeta):
    def __aiter__(self):
        pass
    def __subclasshook__(cls, C):
        pass
class AsyncIterator(AsyncIterable):
    def __aiter__(self):
        pass
    def __subclasshook__(cls, C):
        pass
class AsyncGenerator(AsyncIterator):
    def __subclasshook__(cls, C):
        pass
class Iterable(metaclass=ABCMeta):
    def __iter__(self):
        pass
    def __subclasshook__(cls, C):
        pass
class Iterator(Iterable):
    def __next__(self):
        pass
    def __iter__(self):
        pass
    def __subclasshook__(cls, C):
        pass
class Reversible(Iterable):
    def __reversed__(self):
        pass
    def __subclasshook__(cls, C):
        pass
class Generator(Iterator):
    def __next__(self):
        pass
    def send(self, value):
        pass
    def throw(self, typ, val=None, tb=None):
        pass
    def close(self):
        pass
    def __subclasshook__(cls, C):
        pass
class Sized(metaclass=ABCMeta):
    def __len__(self):
        pass
    def __subclasshook__(cls, C):
        pass
class Container(metaclass=ABCMeta):
    def __contains__(self, x):
        pass
    def __subclasshook__(cls, C):
        pass
class Collection(Sized, Iterable, Container):
    def __subclasshook__(cls, C):
        pass
class Callable(metaclass=ABCMeta):
    def __call__(self, *args, **kwds):
        pass
    def __subclasshook__(cls, C):
        pass
class Set(Collection):
    def __le__(self, other):
        pass
    def __lt__(self, other):
        pass
    def __gt__(self, other):
        pass
    def __ge__(self, other):
        pass
    def __eq__(self, other):
        pass
    def _from_iterable(cls, it):
        pass
    def __and__(self, other):
        pass
    def isdisjoint(self, other):
        pass
    def __or__(self, other):
        pass
    def __sub__(self, other):
        pass
    def __rsub__(self, other):
        pass
    def __xor__(self, other):
        pass
    def _hash(self):
        pass
class MutableSet(Set):
    def add(self, value):
        pass
    def discard(self, value):
        pass
    def remove(self, value):
        pass
    def pop(self):
        pass
    def clear(self):
        pass
    def __ior__(self, it):
        pass
    def __iand__(self, it):
        pass
    def __ixor__(self, it):
        pass
    def __isub__(self, it):
        pass
class Mapping(Collection):
    def __getitem__(self, key):
        pass
    def get(self, key, default=None):
        pass
    def __contains__(self, key):
        pass
    def keys(self):
        pass
    def items(self):
        pass
    def values(self):
        pass
    def __eq__(self, other):
        pass
class MappingView(Sized):
    def __init__(self, mapping):
        pass
    def __len__(self):
        pass
    def __repr__(self):
        pass
class KeysView(MappingView, Set):
    def _from_iterable(self, it):
        pass
    def __contains__(self, key):
        pass
    def __iter__(self):
        pass
class ItemsView(MappingView, Set):
    def _from_iterable(self, it):
        pass
    def __contains__(self, item):
        pass
    def __iter__(self):
        pass
class ValuesView(MappingView, Collection):
    def __contains__(self, value):
        pass
    def __iter__(self):
        pass
class MutableMapping(Mapping):
    def __setitem__(self, key, value):
        pass
    def __delitem__(self, key):
        pass
    def pop(self, key, default=__marker):
        pass
    def popitem(self):
        pass
    def clear(self):
        pass
    def update(self, other=(), /, **kwds):
        pass
    def setdefault(self, key, default=None):
        pass
class Sequence(Reversible, Collection):
    def __getitem__(self, index):
        pass
    def __iter__(self):
        pass
    def __contains__(self, value):
        pass
    def __reversed__(self):
        pass
    def index(self, value, start=0, stop=None):
        pass
    def count(self, value):
        pass
class ByteString(Sequence):
class MutableSequence(Sequence):
    def __setitem__(self, index, value):
        pass
    def __delitem__(self, index):
        pass
    def insert(self, index, value):
        pass
    def append(self, value):
        pass
    def clear(self):
        pass
    def reverse(self):
        pass
    def extend(self, values):
        pass
    def pop(self, index=-1):
        pass
    def remove(self, value):
        pass
    def __iadd__(self, values):
        pass
"""# _compat_pickle.py #"""
"""# _compression.py #"""
class BaseStream(io.BufferedIOBase):
    def _check_not_closed(self):
        pass
    def _check_can_read(self):
        pass
    def _check_can_write(self):
        pass
    def _check_can_seek(self):
        pass
class DecompressReader(io.RawIOBase):
    def readable(self):
        pass
    def __init__(self, fp, decomp_factory, trailing_error=(), **decomp_args):
        pass
    def close(self):
        pass
    def seekable(self):
        pass
    def readinto(self, b):
        pass
    def read(self, size=-1):
        pass
    def _rewind(self):
        pass
    def seek(self, offset, whence=io.SEEK_SET):
        pass
    def tell(self):
        pass
"""# _markupbase.py #"""
class ParserBase:
    def __init__(self):
        pass
    def error(self, message):
        pass
    def reset(self):
        pass
    def getpos(self):
        pass
    def updatepos(self, i, j):
        pass
    def parse_declaration(self, i):
        pass
    def parse_marked_section(self, i, report=1):
        pass
    def parse_comment(self, i, report=1):
        pass
    def _parse_doctype_subset(self, i, declstartpos):
        pass
    def _parse_doctype_element(self, i, declstartpos):
        pass
    def _parse_doctype_attlist(self, i, declstartpos):
        pass
    def _parse_doctype_notation(self, i, declstartpos):
        pass
    def _parse_doctype_entity(self, i, declstartpos):
        pass
    def _scan_name(self, i, declstartpos):
        pass
    def unknown_decl(self, data):
        pass
"""# _osx_support.py #"""
def _find_executable(executable, path=None):
   pass
def _read_output(commandstring, capture_stderr=False):
   pass
def _find_build_tool(toolname):
   pass
def _get_system_version():
   pass
def _get_system_version_tuple():
   pass
def _remove_original_values(_config_vars):
   pass
def _save_modified_value(_config_vars, cv, newvalue):
   pass
def _default_sysroot(cc):
   pass
def _supports_universal_builds():
   pass
def _find_appropriate_compiler(_config_vars):
   pass
def _remove_universal_flags(_config_vars):
   pass
def _remove_unsupported_archs(_config_vars):
   pass
def _override_all_archs(_config_vars):
   pass
def _check_for_unavailable_sdk(_config_vars):
   pass
def compiler_fixup(compiler_so, cc_args):
   pass
def customize_config_vars(_config_vars):
   pass
def customize_compiler(_config_vars):
   pass
def get_platform_osx(_config_vars, osname, release, machine):
   pass
"""# _pydecimal.py #"""
class DecimalException(ArithmeticError):
    def handle(self, context, *args):
        pass
class Clamped(DecimalException):
class InvalidOperation(DecimalException):
    def handle(self, context, *args):
        pass
class ConversionSyntax(InvalidOperation):
    def handle(self, context, *args):
        pass
class DivisionByZero(DecimalException, ZeroDivisionError):
    def handle(self, context, sign, *args):
        pass
class DivisionImpossible(InvalidOperation):
    def handle(self, context, *args):
        pass
class DivisionUndefined(InvalidOperation, ZeroDivisionError):
    def handle(self, context, *args):
        pass
class Inexact(DecimalException):
class InvalidContext(InvalidOperation):
    def handle(self, context, *args):
        pass
class Rounded(DecimalException):
class Subnormal(DecimalException):
class Overflow(Inexact, Rounded):
    def handle(self, context, sign, *args):
        pass
class Underflow(Inexact, Rounded, Subnormal):
class FloatOperation(DecimalException, TypeError):
def getcontext():
   pass
def setcontext(context):
   pass
def localcontext(ctx=None):
   pass
        def sin(x):
                pass
         def sin(x):
                  pass
class Decimal(object):
    def __new__(cls, value="0", context=None):
        pass
    def from_float(cls, f):
        pass
    def _isnan(self):
        pass
    def _isinfinity(self):
        pass
    def _check_nans(self, other=None, context=None):
        pass
    def _compare_check_nans(self, other, context):
        pass
    def __bool__(self):
        pass
    def _cmp(self, other):
        pass
    def __eq__(self, other, context=None):
        pass
    def __lt__(self, other, context=None):
        pass
    def __le__(self, other, context=None):
        pass
    def __gt__(self, other, context=None):
        pass
    def __ge__(self, other, context=None):
        pass
    def compare(self, other, context=None):
        pass
    def __hash__(self):
        pass
    def as_tuple(self):
        pass
    def as_integer_ratio(self):
        pass
    def __repr__(self):
        pass
    def __str__(self, eng=False, context=None):
        pass
    def to_eng_string(self, context=None):
        pass
    def __neg__(self, context=None):
        pass
    def __pos__(self, context=None):
        pass
    def __abs__(self, round=True, context=None):
        pass
    def __add__(self, other, context=None):
        pass
    def __sub__(self, other, context=None):
        pass
    def __rsub__(self, other, context=None):
        pass
    def __mul__(self, other, context=None):
        pass
    def __truediv__(self, other, context=None):
        pass
    def _divide(self, other, context):
        pass
    def __rtruediv__(self, other, context=None):
        pass
    def __divmod__(self, other, context=None):
        pass
    def __rdivmod__(self, other, context=None):
        pass
    def __mod__(self, other, context=None):
        pass
    def __rmod__(self, other, context=None):
        pass
    def remainder_near(self, other, context=None):
        pass
    def __floordiv__(self, other, context=None):
        pass
    def __rfloordiv__(self, other, context=None):
        pass
    def __float__(self):
        pass
    def __int__(self):
        pass
    def real(self):
        pass
    def imag(self):
        pass
    def conjugate(self):
        pass
    def __complex__(self):
        pass
    def _fix_nan(self, context):
        pass
    def _fix(self, context):
        pass
    def _round_down(self, prec):
        pass
    def _round_up(self, prec):
        pass
    def _round_half_up(self, prec):
        pass
    def _round_half_down(self, prec):
        pass
    def _round_half_even(self, prec):
        pass
    def _round_ceiling(self, prec):
        pass
    def _round_floor(self, prec):
        pass
    def __round__(self, n=None):
        pass
    def __floor__(self):
        pass
    def __ceil__(self):
        pass
    def fma(self, other, third, context=None):
        pass
    def _power_modulo(self, other, modulo, context=None):
        pass
    def _power_exact(self, other, p):
        pass
    def __pow__(self, other, modulo=None, context=None):
        pass
    def __rpow__(self, other, context=None):
        pass
    def normalize(self, context=None):
        pass
    def quantize(self, exp, rounding=None, context=None):
        pass
    def same_quantum(self, other, context=None):
        pass
    def _rescale(self, exp, rounding):
        pass
    def _round(self, places, rounding):
        pass
    def to_integral_exact(self, rounding=None, context=None):
        pass
    def to_integral_value(self, rounding=None, context=None):
        pass
    def sqrt(self, context=None):
        pass
    def max(self, other, context=None):
        pass
    def min(self, other, context=None):
        pass
    def _isinteger(self):
        pass
    def _iseven(self):
        pass
    def adjusted(self):
        pass
    def canonical(self):
        pass
    def compare_signal(self, other, context=None):
        pass
    def compare_total(self, other, context=None):
        pass
    def compare_total_mag(self, other, context=None):
        pass
    def copy_abs(self):
        pass
    def copy_negate(self):
        pass
    def copy_sign(self, other, context=None):
        pass
    def exp(self, context=None):
        pass
    def is_canonical(self):
        pass
    def is_finite(self):
        pass
    def is_infinite(self):
        pass
    def is_nan(self):
        pass
    def is_normal(self, context=None):
        pass
    def is_qnan(self):
        pass
    def is_signed(self):
        pass
    def is_snan(self):
        pass
    def is_subnormal(self, context=None):
        pass
    def is_zero(self):
        pass
    def _ln_exp_bound(self):
        pass
    def ln(self, context=None):
        pass
    def logb(self, context=None):
        pass
    def _islogical(self):
        pass
    def _fill_logical(self, context, opa, opb):
        pass
    def logical_and(self, other, context=None):
        pass
    def logical_invert(self, context=None):
        pass
    def logical_or(self, other, context=None):
        pass
    def logical_xor(self, other, context=None):
        pass
    def max_mag(self, other, context=None):
        pass
    def min_mag(self, other, context=None):
        pass
    def next_minus(self, context=None):
        pass
    def next_plus(self, context=None):
        pass
    def next_toward(self, other, context=None):
        pass
    def number_class(self, context=None):
        pass
    def radix(self):
        pass
    def rotate(self, other, context=None):
        pass
    def scaleb(self, other, context=None):
        pass
    def shift(self, other, context=None):
        pass
    def __reduce__(self):
        pass
    def __copy__(self):
        pass
    def __deepcopy__(self, memo):
        pass
    def __format__(self, specifier, context=None, _localeconv=None):
        pass
def _dec_from_triple(sign, coefficient, exponent, special=False):
   pass
class _ContextManager(object):
    def __init__(self, new_context):
        pass
    def __enter__(self):
        pass
    def __exit__(self, t, v, tb):
        pass
class Context(object):
    def _set_integer_check(self, name, value, vmin, vmax):
        pass
    def _set_signal_dict(self, name, d):
        pass
    def __setattr__(self, name, value):
        pass
    def __delattr__(self, name):
        pass
    def __reduce__(self):
        pass
    def __repr__(self):
        pass
    def clear_flags(self):
        pass
    def clear_traps(self):
        pass
    def _shallow_copy(self):
        pass
    def copy(self):
        pass
    def _raise_error(self, condition, explanation = None, *args):
        pass
    def _ignore_all_flags(self):
        pass
    def _ignore_flags(self, *flags):
        pass
    def _regard_flags(self, *flags):
        pass
    def Etiny(self):
        pass
    def Etop(self):
        pass
    def _set_rounding(self, type):
        pass
    def create_decimal(self, num='0'):
        pass
    def create_decimal_from_float(self, f):
        pass
    def abs(self, a):
        pass
    def add(self, a, b):
        pass
    def _apply(self, a):
        pass
    def canonical(self, a):
        pass
    def compare(self, a, b):
        pass
    def compare_signal(self, a, b):
        pass
    def compare_total(self, a, b):
        pass
    def compare_total_mag(self, a, b):
        pass
    def copy_abs(self, a):
        pass
    def copy_decimal(self, a):
        pass
    def copy_negate(self, a):
        pass
    def copy_sign(self, a, b):
        pass
    def divide(self, a, b):
        pass
    def divide_int(self, a, b):
        pass
    def divmod(self, a, b):
        pass
    def exp(self, a):
        pass
    def fma(self, a, b, c):
        pass
    def is_canonical(self, a):
        pass
    def is_finite(self, a):
        pass
    def is_infinite(self, a):
        pass
    def is_nan(self, a):
        pass
    def is_normal(self, a):
        pass
    def is_qnan(self, a):
        pass
    def is_signed(self, a):
        pass
    def is_snan(self, a):
        pass
    def is_subnormal(self, a):
        pass
    def is_zero(self, a):
        pass
    def ln(self, a):
        pass
    def logb(self, a):
        pass
    def logical_and(self, a, b):
        pass
    def logical_invert(self, a):
        pass
    def logical_or(self, a, b):
        pass
    def logical_xor(self, a, b):
        pass
    def max(self, a, b):
        pass
    def max_mag(self, a, b):
        pass
    def min(self, a, b):
        pass
    def min_mag(self, a, b):
        pass
    def minus(self, a):
        pass
    def multiply(self, a, b):
        pass
    def next_minus(self, a):
        pass
    def next_plus(self, a):
        pass
    def next_toward(self, a, b):
        pass
    def normalize(self, a):
        pass
    def number_class(self, a):
        pass
    def plus(self, a):
        pass
    def power(self, a, b, modulo=None):
        pass
    def quantize(self, a, b):
        pass
    def radix(self):
        pass
    def remainder(self, a, b):
        pass
    def remainder_near(self, a, b):
        pass
    def rotate(self, a, b):
        pass
    def same_quantum(self, a, b):
        pass
    def scaleb (self, a, b):
        pass
    def shift(self, a, b):
        pass
    def sqrt(self, a):
        pass
    def subtract(self, a, b):
        pass
    def to_eng_string(self, a):
        pass
    def to_sci_string(self, a):
        pass
    def to_integral_exact(self, a):
        pass
    def to_integral_value(self, a):
        pass
class _WorkRep(object):
    def __init__(self, value=None):
        pass
    def __repr__(self):
        pass
def _normalize(op1, op2, prec = 0):
   pass
def _decimal_lshift_exact(n, e):
   pass
def _sqrt_nearest(n, a):
   pass
def _rshift_nearest(x, shift):
   pass
def _div_nearest(a, b):
   pass
def _ilog(x, M, L = 8):
   pass
def _dlog(c, e, p):
   pass
    def __init__(self):
        pass
    def getdigits(self, p):
        pass
def _iexp(x, M, L=8):
   pass
def _dexp(c, e, p):
   pass
def _dpower(xc, xe, yc, ye, p):
   pass
def _convert_other(other, raiseit=False, allow_float=False):
   pass
def _convert_for_comparison(self, other, equality_op=False):
   pass
def _parse_format_specifier(format_spec, _localeconv=None):
   pass
def _format_align(sign, body, spec):
   pass
def _group_lengths(grouping):
   pass
def _insert_thousands_sep(digits, spec, min_width=1):
   pass
def _format_sign(is_negative, spec):
   pass
def _format_number(is_negative, intpart, fracpart, exp, spec):
   pass
"""# _pyio.py #"""
def _open_code_with_warning(path):
   pass
class DocDescriptor:
    def __get__(self, obj, typ=None):
        pass
class OpenWrapper:
    def __new__(cls, *args, **kwargs):
        pass
    class UnsupportedOperation(OSError, ValueError):
class IOBase(metaclass=abc.ABCMeta):
    def _unsupported(self, name):
        pass
    def seek(self, pos, whence=0):
        pass
    def tell(self):
        pass
    def truncate(self, pos=None):
        pass
    def flush(self):
        pass
    def close(self):
        pass
    def __del__(self):
        pass
    def seekable(self):
        pass
    def _checkSeekable(self, msg=None):
        pass
    def readable(self):
        pass
    def _checkReadable(self, msg=None):
        pass
    def writable(self):
        pass
    def _checkWritable(self, msg=None):
        pass
    def closed(self):
        pass
    def _checkClosed(self, msg=None):
        pass
    def __enter__(self):  # That's a forward reference
        pass
    def __exit__(self, *args):
        pass
    def fileno(self):
        pass
    def isatty(self):
        pass
    def readline(self, size=-1):
        pass
            def nreadahead():
                        pass
            def nreadahead():
                        pass
    def __iter__(self):
        pass
    def __next__(self):
        pass
    def readlines(self, hint=None):
        pass
    def writelines(self, lines):
        pass
class RawIOBase(IOBase):
    def read(self, size=-1):
        pass
    def readall(self):
        pass
    def readinto(self, b):
        pass
    def write(self, b):
        pass
class BufferedIOBase(IOBase):
    def read(self, size=-1):
        pass
    def readinto(self, b):
        pass
    def _readinto(self, b, read1):
        pass
    def write(self, b):
        pass
    def detach(self):
        pass
class _BufferedIOMixin(BufferedIOBase):
    def __init__(self, raw):
        pass
    def seek(self, pos, whence=0):
        pass
    def tell(self):
        pass
    def truncate(self, pos=None):
        pass
    def flush(self):
        pass
    def close(self):
        pass
    def detach(self):
        pass
    def seekable(self):
        pass
    def raw(self):
        pass
    def closed(self):
        pass
    def name(self):
        pass
    def mode(self):
        pass
    def __getstate__(self):
        pass
    def __repr__(self):
        pass
    def fileno(self):
        pass
    def isatty(self):
        pass
class BytesIO(BufferedIOBase):
    def __init__(self, initial_bytes=None):
        pass
    def __getstate__(self):
        pass
    def getvalue(self):
        pass
    def getbuffer(self):
        pass
    def close(self):
        pass
    def read(self, size=-1):
        pass
    def write(self, b):
        pass
    def seek(self, pos, whence=0):
        pass
    def tell(self):
        pass
    def truncate(self, pos=None):
        pass
    def readable(self):
        pass
    def writable(self):
        pass
    def seekable(self):
        pass
class BufferedReader(_BufferedIOMixin):
    def __init__(self, raw, buffer_size=DEFAULT_BUFFER_SIZE):
        pass
    def readable(self):
        pass
    def _reset_read_buf(self):
        pass
    def read(self, size=None):
        pass
    def _read_unlocked(self, n=None):
        pass
    def peek(self, size=0):
        pass
    def _peek_unlocked(self, n=0):
        pass
    def _readinto(self, buf, read1):
        pass
    def tell(self):
        pass
    def seek(self, pos, whence=0):
        pass
class BufferedWriter(_BufferedIOMixin):
    def __init__(self, raw, buffer_size=DEFAULT_BUFFER_SIZE):
        pass
    def writable(self):
        pass
    def write(self, b):
        pass
    def truncate(self, pos=None):
        pass
    def flush(self):
        pass
    def _flush_unlocked(self):
        pass
    def tell(self):
        pass
    def seek(self, pos, whence=0):
        pass
    def close(self):
        pass
class BufferedRWPair(BufferedIOBase):
    def __init__(self, reader, writer, buffer_size=DEFAULT_BUFFER_SIZE):
        pass
    def read(self, size=-1):
        pass
    def readinto(self, b):
        pass
    def write(self, b):
        pass
    def peek(self, size=0):
        pass
    def readable(self):
        pass
    def writable(self):
        pass
    def flush(self):
        pass
    def close(self):
        pass
    def isatty(self):
        pass
    def closed(self):
        pass
class BufferedRandom(BufferedWriter, BufferedReader):
    def __init__(self, raw, buffer_size=DEFAULT_BUFFER_SIZE):
        pass
    def seek(self, pos, whence=0):
        pass
    def tell(self):
        pass
    def truncate(self, pos=None):
        pass
    def read(self, size=None):
        pass
    def readinto(self, b):
        pass
    def peek(self, size=0):
        pass
    def write(self, b):
        pass
class FileIO(RawIOBase):
    def __init__(self, file, mode='r', closefd=True, opener=None):
        pass
    def __del__(self):
        pass
    def __getstate__(self):
        pass
    def __repr__(self):
        pass
    def _checkReadable(self):
        pass
    def _checkWritable(self, msg=None):
        pass
    def read(self, size=None):
        pass
    def readall(self):
        pass
    def readinto(self, b):
        pass
    def write(self, b):
        pass
    def seek(self, pos, whence=SEEK_SET):
        pass
    def tell(self):
        pass
    def truncate(self, size=None):
        pass
    def close(self):
        pass
    def seekable(self):
        pass
    def readable(self):
        pass
    def writable(self):
        pass
    def fileno(self):
        pass
    def isatty(self):
        pass
    def closefd(self):
        pass
    def mode(self):
        pass
class TextIOBase(IOBase):
    def read(self, size=-1):
        pass
    def write(self, s):
        pass
    def truncate(self, pos=None):
        pass
    def readline(self):
        pass
    def detach(self):
        pass
    def encoding(self):
        pass
    def newlines(self):
        pass
    def errors(self):
        pass
class IncrementalNewlineDecoder(codecs.IncrementalDecoder):
    def __init__(self, decoder, translate, errors='strict'):
        pass
    def decode(self, input, final=False):
        pass
    def getstate(self):
        pass
    def setstate(self, state):
        pass
    def reset(self):
        pass
    def newlines(self):
        pass
class TextIOWrapper(TextIOBase):
    def _check_newline(self, newline):
        pass
    def __repr__(self):
        pass
    def encoding(self):
        pass
    def errors(self):
        pass
    def line_buffering(self):
        pass
    def write_through(self):
        pass
    def buffer(self):
        pass
    def seekable(self):
        pass
    def readable(self):
        pass
    def writable(self):
        pass
    def flush(self):
        pass
    def close(self):
        pass
    def closed(self):
        pass
    def name(self):
        pass
    def fileno(self):
        pass
    def isatty(self):
        pass
    def write(self, s):
        pass
    def _get_encoder(self):
        pass
    def _get_decoder(self):
        pass
    def _set_decoded_chars(self, chars):
        pass
    def _get_decoded_chars(self, n=None):
        pass
    def _rewind_decoded_chars(self, n):
        pass
    def _read_chunk(self):
        pass
    def _unpack_cookie(self, bigint):
        pass
    def tell(self):
        pass
    def truncate(self, pos=None):
        pass
    def detach(self):
        pass
    def seek(self, cookie, whence=0):
        pass
        def _reset_encoder(position):
                pass
    def read(self, size=None):
        pass
    def __next__(self):
        pass
    def readline(self, size=None):
        pass
    def newlines(self):
        pass
class StringIO(TextIOWrapper):
    def __init__(self, initial_value="", newline="\n"):
        pass
    def getvalue(self):
        pass
    def __repr__(self):
        pass
    def errors(self):
        pass
    def encoding(self):
        pass
    def detach(self):
        pass
"""# _py_abc.py #"""
def get_cache_token():
   pass
class ABCMeta(type):
    def __new__(mcls, name, bases, namespace, /, **kwargs):
        pass
    def register(cls, subclass):
        pass
    def _dump_registry(cls, file=None):
        pass
    def _abc_registry_clear(cls):
        pass
    def _abc_caches_clear(cls):
        pass
    def __instancecheck__(cls, instance):
        pass
    def __subclasscheck__(cls, subclass):
        pass
"""# _sitebuiltins.py #"""
class Quitter(object):
    def __init__(self, name, eof):
        pass
    def __repr__(self):
        pass
    def __call__(self, code=None):
        pass
class _Printer(object):
    def __init__(self, name, data, files=(), dirs=()):
        pass
    def __setup(self):
        pass
    def __repr__(self):
        pass
    def __call__(self):
        pass
class _Helper(object):
    def __repr__(self):
        pass
    def __call__(self, *args, **kwds):
        pass
"""# _strptime.py #"""
def _getlang():
   pass
class LocaleTime(object):
    def __init__(self):
        pass
    def __calc_weekday(self):
        pass
    def __calc_month(self):
        pass
    def __calc_am_pm(self):
        pass
    def __calc_date_time(self):
        pass
    def __calc_timezone(self):
        pass
class TimeRE(dict):
    def __init__(self, locale_time=None):
        pass
    def __seqToRE(self, to_convert, directive):
        pass
    def pattern(self, format):
        pass
    def compile(self, format):
        pass
def _calc_julian_from_U_or_W(year, week_of_year, day_of_week, week_starts_Mon):
   pass
def _calc_julian_from_V(iso_year, iso_week, iso_weekday):
   pass
def _strptime(data_string, format="%a %b %d %H:%M:%S %Y"):
   pass
def _strptime_time(data_string, format="%a %b %d %H:%M:%S %Y"):
   pass
def _strptime_datetime(cls, data_string, format="%a %b %d %H:%M:%S %Y"):
   pass
"""# _threading_local.py #"""
class _localimpl:
    def __init__(self):
        pass
    def get_dict(self):
        pass
    def create_dict(self):
        pass
        def local_deleted(_, key=key):
                pass
        def thread_deleted(_, idt=idt):
                pass
def _patch(self):
   pass
class local:
    def __new__(cls, /, *args, **kw):
        pass
    def __getattribute__(self, name):
        pass
    def __setattr__(self, name, value):
        pass
    def __delattr__(self, name):
        pass
"""# _weakrefset.py #"""
class _IterationGuard:
    def __init__(self, weakcontainer):
        pass
    def __enter__(self):
        pass
    def __exit__(self, e, t, b):
        pass
class WeakSet:
    def __init__(self, data=None):
        pass
        def _remove(item, selfref=ref(self)):
                pass
    def _commit_removals(self):
        pass
    def __iter__(self):
        pass
    def __len__(self):
        pass
    def __contains__(self, item):
        pass
    def __reduce__(self):
        pass
    def add(self, item):
        pass
    def clear(self):
        pass
    def copy(self):
        pass
    def pop(self):
        pass
    def remove(self, item):
        pass
    def discard(self, item):
        pass
    def update(self, other):
        pass
    def __ior__(self, other):
        pass
    def difference(self, other):
        pass
    def difference_update(self, other):
        pass
    def __isub__(self, other):
        pass
    def intersection(self, other):
        pass
    def intersection_update(self, other):
        pass
    def __iand__(self, other):
        pass
    def issubset(self, other):
        pass
    def __lt__(self, other):
        pass
    def issuperset(self, other):
        pass
    def __gt__(self, other):
        pass
    def __eq__(self, other):
        pass
    def symmetric_difference(self, other):
        pass
    def symmetric_difference_update(self, other):
        pass
    def __ixor__(self, other):
        pass
    def union(self, other):
        pass
    def isdisjoint(self, other):
        pass
    def __repr__(self):
        pass
"""# __future__.py #"""
class _Feature:
    def __init__(self, optionalRelease, mandatoryRelease, compiler_flag):
        pass
    def getOptionalRelease(self):
        pass
    def getMandatoryRelease(self):
        pass
    def __repr__(self):
        pass
"""# __phello__.foo.py #"""
