# encoding: utf-8
# module _ast
# from (built-in)
# by generator 1.147
# no doc

# imports
import ast as __ast


# Variables with simple values

PyCF_ALLOW_TOP_LEVEL_AWAIT = 8192

PyCF_ONLY_AST = 1024

PyCF_OPTIMIZED_AST = 33792

PyCF_TYPE_COMMENTS = 4096

# no functions
# classes

class AST(object):
    # no doc
    def __delattr__(self, *args, **kwargs): # real signature unknown
        """ Implement delattr(self, name). """
        pass

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

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

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

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

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

    _attributes = ()
    _fields = ()
    __dict__ = None # (!) real value is "mappingproxy({'__new__': <built-in method __new__ of type object at 0x000002309384A940>, '__getattribute__': <slot wrapper '__getattribute__' of 'ast.AST' objects>, '__setattr__': <slot wrapper '__setattr__' of 'ast.AST' objects>, '__delattr__': <slot wrapper '__delattr__' of 'ast.AST' objects>, '__init__': <slot wrapper '__init__' of 'ast.AST' objects>, '__reduce__': <method '__reduce__' of 'ast.AST' objects>, '__dict__': <attribute '__dict__' of 'ast.AST' objects>, '__doc__': None, '__module__': 'ast', '_fields': (), '__match_args__': (), '_attributes': ()})"
    __match_args__ = ()


class operator(__ast.AST):
    """ operator = Add | Sub | Mult | MatMult | Div | Mod | Pow | LShift | RShift | BitOr | BitXor | BitAnd | FloorDiv """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    __weakref__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """list of weak references to the object"""


    _attributes = ()
    _fields = ()
    __match_args__ = ()


class Add(__ast.operator):
    """ Add """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    _fields = ()
    _field_types = {}
    __annotations__ = {}
    __match_args__ = ()


class alias(__ast.AST):
    """ alias(identifier name, identifier? asname) """
    def __init__(self, identifier_name, identifier, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    __weakref__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """list of weak references to the object"""


    asname = None
    end_col_offset = None
    end_lineno = None
    _attributes = (
        'lineno',
        'col_offset',
        'end_lineno',
        'end_col_offset',
    )
    _fields = (
        'name',
        'asname',
    )
    _field_types = {
        'asname': str | None,
        'name': str,
    }
    __annotations__ = {
        'asname': str | None,
        'name': str,
    }
    __match_args__ = (
        'name',
        'asname',
    )


class boolop(__ast.AST):
    """ boolop = And | Or """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    __weakref__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """list of weak references to the object"""


    _attributes = ()
    _fields = ()
    __match_args__ = ()


class And(__ast.boolop):
    """ And """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    _fields = ()
    _field_types = {}
    __annotations__ = {}
    __match_args__ = ()


class stmt(__ast.AST):
    """
    stmt = FunctionDef(identifier name, arguments args, stmt* body, expr* decorator_list, expr? returns, string? type_comment, type_param* type_params)
         | AsyncFunctionDef(identifier name, arguments args, stmt* body, expr* decorator_list, expr? returns, string? type_comment, type_param* type_params)
         | ClassDef(identifier name, expr* bases, keyword* keywords, stmt* body, expr* decorator_list, type_param* type_params)
         | Return(expr? value)
         | Delete(expr* targets)
         | Assign(expr* targets, expr value, string? type_comment)
         | TypeAlias(expr name, type_param* type_params, expr value)
         | AugAssign(expr target, operator op, expr value)
         | AnnAssign(expr target, expr annotation, expr? value, int simple)
         | For(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)
         | AsyncFor(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)
         | While(expr test, stmt* body, stmt* orelse)
         | If(expr test, stmt* body, stmt* orelse)
         | With(withitem* items, stmt* body, string? type_comment)
         | AsyncWith(withitem* items, stmt* body, string? type_comment)
         | Match(expr subject, match_case* cases)
         | Raise(expr? exc, expr? cause)
         | Try(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)
         | TryStar(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)
         | Assert(expr test, expr? msg)
         | Import(alias* names)
         | ImportFrom(identifier? module, alias* names, int? level)
         | Global(identifier* names)
         | Nonlocal(identifier* names)
         | Expr(expr value)
         | Pass
         | Break
         | Continue
    """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    __weakref__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """list of weak references to the object"""


    end_col_offset = None
    end_lineno = None
    _attributes = (
        'lineno',
        'col_offset',
        'end_lineno',
        'end_col_offset',
    )
    _fields = ()
    __match_args__ = ()


class AnnAssign(__ast.stmt):
    """ AnnAssign(expr target, expr annotation, expr? value, int simple) """
    def __init__(self, expr_target, expr_annotation, expr, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    value = None
    _fields = (
        'target',
        'annotation',
        'value',
        'simple',
    )
    _field_types = {
        'annotation': None, # (!) forward: expr, real value is "<class 'ast.expr'>"
        'simple': int,
        'target': '<value is a self-reference, replaced by this string>',
        'value': ast.expr | None,
    }
    __annotations__ = {
        'annotation': None, # (!) forward: expr, real value is "<class 'ast.expr'>"
        'simple': int,
        'target': '<value is a self-reference, replaced by this string>',
        'value': ast.expr | None,
    }
    __match_args__ = (
        'target',
        'annotation',
        'value',
        'simple',
    )


class arg(__ast.AST):
    """ arg(identifier arg, expr? annotation, string? type_comment) """
    def __init__(self, identifier_arg, expr, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    __weakref__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """list of weak references to the object"""


    annotation = None
    end_col_offset = None
    end_lineno = None
    type_comment = None
    _attributes = (
        'lineno',
        'col_offset',
        'end_lineno',
        'end_col_offset',
    )
    _fields = (
        'arg',
        'annotation',
        'type_comment',
    )
    _field_types = {
        'annotation': ast.expr | None,
        'arg': str,
        'type_comment': str | None,
    }
    __annotations__ = {
        'annotation': ast.expr | None,
        'arg': str,
        'type_comment': str | None,
    }
    __match_args__ = (
        'arg',
        'annotation',
        'type_comment',
    )


class arguments(__ast.AST):
    """ arguments(arg* posonlyargs, arg* args, arg? vararg, arg* kwonlyargs, expr* kw_defaults, arg? kwarg, expr* defaults) """
    def __init__(self, arg, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    __weakref__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """list of weak references to the object"""


    kwarg = None
    vararg = None
    _attributes = ()
    _fields = (
        'posonlyargs',
        'args',
        'vararg',
        'kwonlyargs',
        'kw_defaults',
        'kwarg',
        'defaults',
    )
    _field_types = {
        'args': list[ast.arg],
        'defaults': list[ast.expr],
        'kw_defaults': '<value is a self-reference, replaced by this string>',
        'kwarg': ast.arg | None,
        'kwonlyargs': '<value is a self-reference, replaced by this string>',
        'posonlyargs': '<value is a self-reference, replaced by this string>',
        'vararg': '<value is a self-reference, replaced by this string>',
    }
    __annotations__ = {
        'args': list[ast.arg],
        'defaults': list[ast.expr],
        'kw_defaults': '<value is a self-reference, replaced by this string>',
        'kwarg': ast.arg | None,
        'kwonlyargs': '<value is a self-reference, replaced by this string>',
        'posonlyargs': '<value is a self-reference, replaced by this string>',
        'vararg': '<value is a self-reference, replaced by this string>',
    }
    __match_args__ = (
        'posonlyargs',
        'args',
        'vararg',
        'kwonlyargs',
        'kw_defaults',
        'kwarg',
        'defaults',
    )


class Assert(__ast.stmt):
    """ Assert(expr test, expr? msg) """
    def __init__(self, expr_test, expr, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    msg = None
    _fields = (
        'test',
        'msg',
    )
    _field_types = {
        'msg': ast.expr | None,
        'test': None, # (!) forward: expr, real value is "<class 'ast.expr'>"
    }
    __annotations__ = {
        'msg': ast.expr | None,
        'test': None, # (!) forward: expr, real value is "<class 'ast.expr'>"
    }
    __match_args__ = (
        'test',
        'msg',
    )


class Assign(__ast.stmt):
    """ Assign(expr* targets, expr value, string? type_comment) """
    def __init__(self, expr, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    type_comment = None
    _fields = (
        'targets',
        'value',
        'type_comment',
    )
    _field_types = {
        'targets': list[ast.expr],
        'type_comment': str | None,
        'value': None, # (!) forward: expr, real value is "<class 'ast.expr'>"
    }
    __annotations__ = {
        'targets': list[ast.expr],
        'type_comment': str | None,
        'value': None, # (!) forward: expr, real value is "<class 'ast.expr'>"
    }
    __match_args__ = (
        'targets',
        'value',
        'type_comment',
    )


class AsyncFor(__ast.stmt):
    """ AsyncFor(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment) """
    def __init__(self, expr_target, expr_iter, stmt, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    type_comment = None
    _fields = (
        'target',
        'iter',
        'body',
        'orelse',
        'type_comment',
    )
    _field_types = {
        'body': list[ast.stmt],
        'iter': None, # (!) forward: expr, real value is "<class 'ast.expr'>"
        'orelse': '<value is a self-reference, replaced by this string>',
        'target': '<value is a self-reference, replaced by this string>',
        'type_comment': str | None,
    }
    __annotations__ = {
        'body': list[ast.stmt],
        'iter': None, # (!) forward: expr, real value is "<class 'ast.expr'>"
        'orelse': '<value is a self-reference, replaced by this string>',
        'target': '<value is a self-reference, replaced by this string>',
        'type_comment': str | None,
    }
    __match_args__ = (
        'target',
        'iter',
        'body',
        'orelse',
        'type_comment',
    )


class AsyncFunctionDef(__ast.stmt):
    """ AsyncFunctionDef(identifier name, arguments args, stmt* body, expr* decorator_list, expr? returns, string? type_comment, type_param* type_params) """
    def __init__(self, identifier_name, arguments_args, stmt, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    returns = None
    type_comment = None
    _fields = (
        'name',
        'args',
        'body',
        'decorator_list',
        'returns',
        'type_comment',
        'type_params',
    )
    _field_types = {
        'args': arguments,
        'body': list[ast.stmt],
        'decorator_list': list[ast.expr],
        'name': str,
        'returns': ast.expr | None,
        'type_comment': str | None,
        'type_params': list[ast.type_param],
    }
    __annotations__ = {
        'args': arguments,
        'body': list[ast.stmt],
        'decorator_list': list[ast.expr],
        'name': str,
        'returns': ast.expr | None,
        'type_comment': str | None,
        'type_params': list[ast.type_param],
    }
    __match_args__ = (
        'name',
        'args',
        'body',
        'decorator_list',
        'returns',
        'type_comment',
        'type_params',
    )


class AsyncWith(__ast.stmt):
    """ AsyncWith(withitem* items, stmt* body, string? type_comment) """
    def __init__(self, withitem, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    type_comment = None
    _fields = (
        'items',
        'body',
        'type_comment',
    )
    _field_types = {
        'body': list[ast.stmt],
        'items': list[ast.withitem],
        'type_comment': str | None,
    }
    __annotations__ = {
        'body': list[ast.stmt],
        'items': list[ast.withitem],
        'type_comment': str | None,
    }
    __match_args__ = (
        'items',
        'body',
        'type_comment',
    )


class expr(__ast.AST):
    """
    expr = BoolOp(boolop op, expr* values)
         | NamedExpr(expr target, expr value)
         | BinOp(expr left, operator op, expr right)
         | UnaryOp(unaryop op, expr operand)
         | Lambda(arguments args, expr body)
         | IfExp(expr test, expr body, expr orelse)
         | Dict(expr* keys, expr* values)
         | Set(expr* elts)
         | ListComp(expr elt, comprehension* generators)
         | SetComp(expr elt, comprehension* generators)
         | DictComp(expr key, expr value, comprehension* generators)
         | GeneratorExp(expr elt, comprehension* generators)
         | Await(expr value)
         | Yield(expr? value)
         | YieldFrom(expr value)
         | Compare(expr left, cmpop* ops, expr* comparators)
         | Call(expr func, expr* args, keyword* keywords)
         | FormattedValue(expr value, int conversion, expr? format_spec)
         | JoinedStr(expr* values)
         | Constant(constant value, string? kind)
         | Attribute(expr value, identifier attr, expr_context ctx)
         | Subscript(expr value, expr slice, expr_context ctx)
         | Starred(expr value, expr_context ctx)
         | Name(identifier id, expr_context ctx)
         | List(expr* elts, expr_context ctx)
         | Tuple(expr* elts, expr_context ctx)
         | Slice(expr? lower, expr? upper, expr? step)
    """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    __weakref__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """list of weak references to the object"""


    end_col_offset = None
    end_lineno = None
    _attributes = (
        'lineno',
        'col_offset',
        'end_lineno',
        'end_col_offset',
    )
    _fields = ()
    __match_args__ = ()


class Attribute(__ast.expr):
    """ Attribute(expr value, identifier attr, expr_context ctx) """
    def __init__(self, expr_value, identifier_attr, expr_context_ctx): # real signature unknown; restored from __doc__
        pass

    _fields = (
        'value',
        'attr',
        'ctx',
    )
    _field_types = {
        'attr': str,
        'ctx': None, # (!) forward: expr_context, real value is "<class 'ast.expr_context'>"
        'value': expr,
    }
    __annotations__ = {
        'attr': str,
        'ctx': None, # (!) forward: expr_context, real value is "<class 'ast.expr_context'>"
        'value': expr,
    }
    __match_args__ = (
        'value',
        'attr',
        'ctx',
    )


class AugAssign(__ast.stmt):
    """ AugAssign(expr target, operator op, expr value) """
    def __init__(self, expr_target, operator_op, expr_value): # real signature unknown; restored from __doc__
        pass

    _fields = (
        'target',
        'op',
        'value',
    )
    _field_types = {
        'op': operator,
        'target': expr,
        'value': '<value is a self-reference, replaced by this string>',
    }
    __annotations__ = {
        'op': operator,
        'target': expr,
        'value': '<value is a self-reference, replaced by this string>',
    }
    __match_args__ = (
        'target',
        'op',
        'value',
    )


class Await(__ast.expr):
    """ Await(expr value) """
    def __init__(self, expr_value): # real signature unknown; restored from __doc__
        pass

    _fields = (
        'value',
    )
    _field_types = {
        'value': expr,
    }
    __annotations__ = {
        'value': expr,
    }
    __match_args__ = (
        'value',
    )


class BinOp(__ast.expr):
    """ BinOp(expr left, operator op, expr right) """
    def __init__(self, expr_left, operator_op, expr_right): # real signature unknown; restored from __doc__
        pass

    _fields = (
        'left',
        'op',
        'right',
    )
    _field_types = {
        'left': expr,
        'op': operator,
        'right': '<value is a self-reference, replaced by this string>',
    }
    __annotations__ = {
        'left': expr,
        'op': operator,
        'right': '<value is a self-reference, replaced by this string>',
    }
    __match_args__ = (
        'left',
        'op',
        'right',
    )


class BitAnd(__ast.operator):
    """ BitAnd """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    _fields = ()
    _field_types = {}
    __annotations__ = {}
    __match_args__ = ()


class BitOr(__ast.operator):
    """ BitOr """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    _fields = ()
    _field_types = {}
    __annotations__ = {}
    __match_args__ = ()


class BitXor(__ast.operator):
    """ BitXor """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    _fields = ()
    _field_types = {}
    __annotations__ = {}
    __match_args__ = ()


class BoolOp(__ast.expr):
    """ BoolOp(boolop op, expr* values) """
    def __init__(self, boolop_op, expr, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    _fields = (
        'op',
        'values',
    )
    _field_types = {
        'op': boolop,
        'values': list[ast.expr],
    }
    __annotations__ = {
        'op': boolop,
        'values': list[ast.expr],
    }
    __match_args__ = (
        'op',
        'values',
    )


class Break(__ast.stmt):
    """ Break """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    _fields = ()
    _field_types = {}
    __annotations__ = {}
    __match_args__ = ()


class Call(__ast.expr):
    """ Call(expr func, expr* args, keyword* keywords) """
    def __init__(self, expr_func, expr, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    _fields = (
        'func',
        'args',
        'keywords',
    )
    _field_types = {
        'args': list[ast.expr],
        'func': expr,
        'keywords': list[ast.keyword],
    }
    __annotations__ = {
        'args': list[ast.expr],
        'func': expr,
        'keywords': list[ast.keyword],
    }
    __match_args__ = (
        'func',
        'args',
        'keywords',
    )


class ClassDef(__ast.stmt):
    """ ClassDef(identifier name, expr* bases, keyword* keywords, stmt* body, expr* decorator_list, type_param* type_params) """
    def __init__(self, identifier_name, expr, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    _fields = (
        'name',
        'bases',
        'keywords',
        'body',
        'decorator_list',
        'type_params',
    )
    _field_types = {
        'bases': list[ast.expr],
        'body': list[ast.stmt],
        'decorator_list': '<value is a self-reference, replaced by this string>',
        'keywords': list[ast.keyword],
        'name': str,
        'type_params': list[ast.type_param],
    }
    __annotations__ = {
        'bases': list[ast.expr],
        'body': list[ast.stmt],
        'decorator_list': '<value is a self-reference, replaced by this string>',
        'keywords': list[ast.keyword],
        'name': str,
        'type_params': list[ast.type_param],
    }
    __match_args__ = (
        'name',
        'bases',
        'keywords',
        'body',
        'decorator_list',
        'type_params',
    )


class cmpop(__ast.AST):
    """ cmpop = Eq | NotEq | Lt | LtE | Gt | GtE | Is | IsNot | In | NotIn """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    __weakref__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """list of weak references to the object"""


    _attributes = ()
    _fields = ()
    __match_args__ = ()


class Compare(__ast.expr):
    """ Compare(expr left, cmpop* ops, expr* comparators) """
    def __init__(self, expr_left, cmpop, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    _fields = (
        'left',
        'ops',
        'comparators',
    )
    _field_types = {
        'comparators': list[ast.expr],
        'left': expr,
        'ops': list[ast.cmpop],
    }
    __annotations__ = {
        'comparators': list[ast.expr],
        'left': expr,
        'ops': list[ast.cmpop],
    }
    __match_args__ = (
        'left',
        'ops',
        'comparators',
    )


class comprehension(__ast.AST):
    """ comprehension(expr target, expr iter, expr* ifs, int is_async) """
    def __init__(self, expr_target, expr_iter, expr, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    __weakref__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """list of weak references to the object"""


    _attributes = ()
    _fields = (
        'target',
        'iter',
        'ifs',
        'is_async',
    )
    _field_types = {
        'ifs': list[ast.expr],
        'is_async': int,
        'iter': expr,
        'target': '<value is a self-reference, replaced by this string>',
    }
    __annotations__ = {
        'ifs': list[ast.expr],
        'is_async': int,
        'iter': expr,
        'target': '<value is a self-reference, replaced by this string>',
    }
    __match_args__ = (
        'target',
        'iter',
        'ifs',
        'is_async',
    )


class Constant(__ast.expr):
    """ Constant(constant value, string? kind) """
    def __init__(self, constant_value, string, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    n = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Deprecated. Use value instead."""

    s = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Deprecated. Use value instead."""


    kind = None
    _fields = (
        'value',
        'kind',
    )
    _field_types = {
        'kind': str | None,
        'value': object,
    }
    __annotations__ = {
        'kind': str | None,
        'value': object,
    }
    __match_args__ = (
        'value',
        'kind',
    )


class Continue(__ast.stmt):
    """ Continue """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    _fields = ()
    _field_types = {}
    __annotations__ = {}
    __match_args__ = ()


class expr_context(__ast.AST):
    """ expr_context = Load | Store | Del """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    __weakref__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """list of weak references to the object"""


    _attributes = ()
    _fields = ()
    __match_args__ = ()


class Del(__ast.expr_context):
    """ Del """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    _fields = ()
    _field_types = {}
    __annotations__ = {}
    __match_args__ = ()


class Delete(__ast.stmt):
    """ Delete(expr* targets) """
    def __init__(self, expr, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    _fields = (
        'targets',
    )
    _field_types = {
        'targets': list[ast.expr],
    }
    __annotations__ = {
        'targets': list[ast.expr],
    }
    __match_args__ = (
        'targets',
    )


class Dict(__ast.expr):
    """ Dict(expr* keys, expr* values) """
    def __init__(self, expr, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    _fields = (
        'keys',
        'values',
    )
    _field_types = {
        'keys': list[ast.expr],
        'values': '<value is a self-reference, replaced by this string>',
    }
    __annotations__ = {
        'keys': list[ast.expr],
        'values': '<value is a self-reference, replaced by this string>',
    }
    __match_args__ = (
        'keys',
        'values',
    )


class DictComp(__ast.expr):
    """ DictComp(expr key, expr value, comprehension* generators) """
    def __init__(self, expr_key, expr_value, comprehension, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    _fields = (
        'key',
        'value',
        'generators',
    )
    _field_types = {
        'generators': list[ast.comprehension],
        'key': expr,
        'value': '<value is a self-reference, replaced by this string>',
    }
    __annotations__ = {
        'generators': list[ast.comprehension],
        'key': expr,
        'value': '<value is a self-reference, replaced by this string>',
    }
    __match_args__ = (
        'key',
        'value',
        'generators',
    )


class Div(__ast.operator):
    """ Div """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    _fields = ()
    _field_types = {}
    __annotations__ = {}
    __match_args__ = ()


class Eq(__ast.cmpop):
    """ Eq """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    _fields = ()
    _field_types = {}
    __annotations__ = {}
    __match_args__ = ()


class excepthandler(__ast.AST):
    """ excepthandler = ExceptHandler(expr? type, identifier? name, stmt* body) """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    __weakref__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """list of weak references to the object"""


    end_col_offset = None
    end_lineno = None
    _attributes = (
        'lineno',
        'col_offset',
        'end_lineno',
        'end_col_offset',
    )
    _fields = ()
    __match_args__ = ()


class ExceptHandler(__ast.excepthandler):
    """ ExceptHandler(expr? type, identifier? name, stmt* body) """
    def __init__(self, expr, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    name = None
    type = None
    _fields = (
        'type',
        'name',
        'body',
    )
    _field_types = {
        'body': list[ast.stmt],
        'name': str | None,
        'type': ast.expr | None,
    }
    __annotations__ = {
        'body': list[ast.stmt],
        'name': str | None,
        'type': ast.expr | None,
    }
    __match_args__ = (
        'type',
        'name',
        'body',
    )


class Expr(__ast.stmt):
    """ Expr(expr value) """
    def __init__(self, expr_value): # real signature unknown; restored from __doc__
        pass

    _fields = (
        'value',
    )
    _field_types = {
        'value': expr,
    }
    __annotations__ = {
        'value': expr,
    }
    __match_args__ = (
        'value',
    )


class mod(__ast.AST):
    """
    mod = Module(stmt* body, type_ignore* type_ignores)
        | Interactive(stmt* body)
        | Expression(expr body)
        | FunctionType(expr* argtypes, expr returns)
    """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    __weakref__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """list of weak references to the object"""


    _attributes = ()
    _fields = ()
    __match_args__ = ()


class Expression(__ast.mod):
    """ Expression(expr body) """
    def __init__(self, expr_body): # real signature unknown; restored from __doc__
        pass

    _fields = (
        'body',
    )
    _field_types = {
        'body': expr,
    }
    __annotations__ = {
        'body': expr,
    }
    __match_args__ = (
        'body',
    )


class FloorDiv(__ast.operator):
    """ FloorDiv """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    _fields = ()
    _field_types = {}
    __annotations__ = {}
    __match_args__ = ()


class For(__ast.stmt):
    """ For(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment) """
    def __init__(self, expr_target, expr_iter, stmt, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    type_comment = None
    _fields = (
        'target',
        'iter',
        'body',
        'orelse',
        'type_comment',
    )
    _field_types = {
        'body': list[ast.stmt],
        'iter': expr,
        'orelse': '<value is a self-reference, replaced by this string>',
        'target': '<value is a self-reference, replaced by this string>',
        'type_comment': str | None,
    }
    __annotations__ = {
        'body': list[ast.stmt],
        'iter': expr,
        'orelse': '<value is a self-reference, replaced by this string>',
        'target': '<value is a self-reference, replaced by this string>',
        'type_comment': str | None,
    }
    __match_args__ = (
        'target',
        'iter',
        'body',
        'orelse',
        'type_comment',
    )


class FormattedValue(__ast.expr):
    """ FormattedValue(expr value, int conversion, expr? format_spec) """
    def __init__(self, expr_value, int_conversion, expr, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    format_spec = None
    _fields = (
        'value',
        'conversion',
        'format_spec',
    )
    _field_types = {
        'conversion': int,
        'format_spec': ast.expr | None,
        'value': expr,
    }
    __annotations__ = {
        'conversion': int,
        'format_spec': ast.expr | None,
        'value': expr,
    }
    __match_args__ = (
        'value',
        'conversion',
        'format_spec',
    )


class FunctionDef(__ast.stmt):
    """ FunctionDef(identifier name, arguments args, stmt* body, expr* decorator_list, expr? returns, string? type_comment, type_param* type_params) """
    def __init__(self, identifier_name, arguments_args, stmt, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    returns = None
    type_comment = None
    _fields = (
        'name',
        'args',
        'body',
        'decorator_list',
        'returns',
        'type_comment',
        'type_params',
    )
    _field_types = {
        'args': arguments,
        'body': list[ast.stmt],
        'decorator_list': list[ast.expr],
        'name': str,
        'returns': ast.expr | None,
        'type_comment': str | None,
        'type_params': list[ast.type_param],
    }
    __annotations__ = {
        'args': arguments,
        'body': list[ast.stmt],
        'decorator_list': list[ast.expr],
        'name': str,
        'returns': ast.expr | None,
        'type_comment': str | None,
        'type_params': list[ast.type_param],
    }
    __match_args__ = (
        'name',
        'args',
        'body',
        'decorator_list',
        'returns',
        'type_comment',
        'type_params',
    )


class FunctionType(__ast.mod):
    """ FunctionType(expr* argtypes, expr returns) """
    def __init__(self, expr, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    _fields = (
        'argtypes',
        'returns',
    )
    _field_types = {
        'argtypes': list[ast.expr],
        'returns': expr,
    }
    __annotations__ = {
        'argtypes': list[ast.expr],
        'returns': expr,
    }
    __match_args__ = (
        'argtypes',
        'returns',
    )


class GeneratorExp(__ast.expr):
    """ GeneratorExp(expr elt, comprehension* generators) """
    def __init__(self, expr_elt, comprehension, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    _fields = (
        'elt',
        'generators',
    )
    _field_types = {
        'elt': expr,
        'generators': list[ast.comprehension],
    }
    __annotations__ = {
        'elt': expr,
        'generators': list[ast.comprehension],
    }
    __match_args__ = (
        'elt',
        'generators',
    )


class Global(__ast.stmt):
    """ Global(identifier* names) """
    def __init__(self, identifier, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    _fields = (
        'names',
    )
    _field_types = {
        'names': list[str],
    }
    __annotations__ = {
        'names': list[str],
    }
    __match_args__ = (
        'names',
    )


class Gt(__ast.cmpop):
    """ Gt """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    _fields = ()
    _field_types = {}
    __annotations__ = {}
    __match_args__ = ()


class GtE(__ast.cmpop):
    """ GtE """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    _fields = ()
    _field_types = {}
    __annotations__ = {}
    __match_args__ = ()


class If(__ast.stmt):
    """ If(expr test, stmt* body, stmt* orelse) """
    def __init__(self, expr_test, stmt, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    _fields = (
        'test',
        'body',
        'orelse',
    )
    _field_types = {
        'body': list[ast.stmt],
        'orelse': '<value is a self-reference, replaced by this string>',
        'test': expr,
    }
    __annotations__ = {
        'body': list[ast.stmt],
        'orelse': '<value is a self-reference, replaced by this string>',
        'test': expr,
    }
    __match_args__ = (
        'test',
        'body',
        'orelse',
    )


class IfExp(__ast.expr):
    """ IfExp(expr test, expr body, expr orelse) """
    def __init__(self, expr_test, expr_body, expr_orelse): # real signature unknown; restored from __doc__
        pass

    _fields = (
        'test',
        'body',
        'orelse',
    )
    _field_types = {
        'body': expr,
        'orelse': '<value is a self-reference, replaced by this string>',
        'test': '<value is a self-reference, replaced by this string>',
    }
    __annotations__ = {
        'body': expr,
        'orelse': '<value is a self-reference, replaced by this string>',
        'test': '<value is a self-reference, replaced by this string>',
    }
    __match_args__ = (
        'test',
        'body',
        'orelse',
    )


class Import(__ast.stmt):
    """ Import(alias* names) """
    def __init__(self, alias, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    _fields = (
        'names',
    )
    _field_types = {
        'names': list[ast.alias],
    }
    __annotations__ = {
        'names': list[ast.alias],
    }
    __match_args__ = (
        'names',
    )


class ImportFrom(__ast.stmt):
    """ ImportFrom(identifier? module, alias* names, int? level) """
    def __init__(self, identifier, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    level = None
    module = None
    _fields = (
        'module',
        'names',
        'level',
    )
    _field_types = {
        'level': int | None,
        'module': str | None,
        'names': list[ast.alias],
    }
    __annotations__ = {
        'level': int | None,
        'module': str | None,
        'names': list[ast.alias],
    }
    __match_args__ = (
        'module',
        'names',
        'level',
    )


class In(__ast.cmpop):
    """ In """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    _fields = ()
    _field_types = {}
    __annotations__ = {}
    __match_args__ = ()


class Interactive(__ast.mod):
    """ Interactive(stmt* body) """
    def __init__(self, stmt, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    _fields = (
        'body',
    )
    _field_types = {
        'body': list[ast.stmt],
    }
    __annotations__ = {
        'body': list[ast.stmt],
    }
    __match_args__ = (
        'body',
    )


class unaryop(__ast.AST):
    """ unaryop = Invert | Not | UAdd | USub """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    __weakref__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """list of weak references to the object"""


    _attributes = ()
    _fields = ()
    __match_args__ = ()


class Invert(__ast.unaryop):
    """ Invert """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    _fields = ()
    _field_types = {}
    __annotations__ = {}
    __match_args__ = ()


class Is(__ast.cmpop):
    """ Is """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    _fields = ()
    _field_types = {}
    __annotations__ = {}
    __match_args__ = ()


class IsNot(__ast.cmpop):
    """ IsNot """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    _fields = ()
    _field_types = {}
    __annotations__ = {}
    __match_args__ = ()


class JoinedStr(__ast.expr):
    """ JoinedStr(expr* values) """
    def __init__(self, expr, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    _fields = (
        'values',
    )
    _field_types = {
        'values': list[ast.expr],
    }
    __annotations__ = {
        'values': list[ast.expr],
    }
    __match_args__ = (
        'values',
    )


class keyword(__ast.AST):
    """ keyword(identifier? arg, expr value) """
    def __init__(self, identifier, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    __weakref__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """list of weak references to the object"""


    arg = None
    end_col_offset = None
    end_lineno = None
    _attributes = (
        'lineno',
        'col_offset',
        'end_lineno',
        'end_col_offset',
    )
    _fields = (
        'arg',
        'value',
    )
    _field_types = {
        'arg': str | None,
        'value': expr,
    }
    __annotations__ = {
        'arg': str | None,
        'value': expr,
    }
    __match_args__ = (
        'arg',
        'value',
    )


class Lambda(__ast.expr):
    """ Lambda(arguments args, expr body) """
    def __init__(self, arguments_args, expr_body): # real signature unknown; restored from __doc__
        pass

    _fields = (
        'args',
        'body',
    )
    _field_types = {
        'args': arguments,
        'body': expr,
    }
    __annotations__ = {
        'args': arguments,
        'body': expr,
    }
    __match_args__ = (
        'args',
        'body',
    )


class List(__ast.expr):
    """ List(expr* elts, expr_context ctx) """
    def __init__(self, expr, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    _fields = (
        'elts',
        'ctx',
    )
    _field_types = {
        'ctx': expr_context,
        'elts': list[ast.expr],
    }
    __annotations__ = {
        'ctx': expr_context,
        'elts': list[ast.expr],
    }
    __match_args__ = (
        'elts',
        'ctx',
    )


class ListComp(__ast.expr):
    """ ListComp(expr elt, comprehension* generators) """
    def __init__(self, expr_elt, comprehension, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    _fields = (
        'elt',
        'generators',
    )
    _field_types = {
        'elt': expr,
        'generators': list[ast.comprehension],
    }
    __annotations__ = {
        'elt': expr,
        'generators': list[ast.comprehension],
    }
    __match_args__ = (
        'elt',
        'generators',
    )


class Load(__ast.expr_context):
    """ Load """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    _fields = ()
    _field_types = {}
    __annotations__ = {}
    __match_args__ = ()


class LShift(__ast.operator):
    """ LShift """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    _fields = ()
    _field_types = {}
    __annotations__ = {}
    __match_args__ = ()


class Lt(__ast.cmpop):
    """ Lt """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    _fields = ()
    _field_types = {}
    __annotations__ = {}
    __match_args__ = ()


class LtE(__ast.cmpop):
    """ LtE """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    _fields = ()
    _field_types = {}
    __annotations__ = {}
    __match_args__ = ()


class Match(__ast.stmt):
    """ Match(expr subject, match_case* cases) """
    def __init__(self, expr_subject, match_case, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    _fields = (
        'subject',
        'cases',
    )
    _field_types = {
        'cases': list[ast.match_case],
        'subject': expr,
    }
    __annotations__ = {
        'cases': list[ast.match_case],
        'subject': expr,
    }
    __match_args__ = (
        'subject',
        'cases',
    )


class pattern(__ast.AST):
    """
    pattern = MatchValue(expr value)
            | MatchSingleton(constant value)
            | MatchSequence(pattern* patterns)
            | MatchMapping(expr* keys, pattern* patterns, identifier? rest)
            | MatchClass(expr cls, pattern* patterns, identifier* kwd_attrs, pattern* kwd_patterns)
            | MatchStar(identifier? name)
            | MatchAs(pattern? pattern, identifier? name)
            | MatchOr(pattern* patterns)
    """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    __weakref__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """list of weak references to the object"""


    _attributes = (
        'lineno',
        'col_offset',
        'end_lineno',
        'end_col_offset',
    )
    _fields = ()
    __match_args__ = ()


class MatchAs(__ast.pattern):
    """ MatchAs(pattern? pattern, identifier? name) """
    def __init__(self, pattern, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    name = None
    pattern = None
    _fields = (
        'pattern',
        'name',
    )
    _field_types = {
        'name': str | None,
        'pattern': ast.pattern | None,
    }
    __annotations__ = {
        'name': str | None,
        'pattern': ast.pattern | None,
    }
    __match_args__ = (
        'pattern',
        'name',
    )


class MatchClass(__ast.pattern):
    """ MatchClass(expr cls, pattern* patterns, identifier* kwd_attrs, pattern* kwd_patterns) """
    def __init__(self, expr_cls, pattern, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    _fields = (
        'cls',
        'patterns',
        'kwd_attrs',
        'kwd_patterns',
    )
    _field_types = {
        'cls': expr,
        'kwd_attrs': list[str],
        'kwd_patterns': list[ast.pattern],
        'patterns': '<value is a self-reference, replaced by this string>',
    }
    __annotations__ = {
        'cls': expr,
        'kwd_attrs': list[str],
        'kwd_patterns': list[ast.pattern],
        'patterns': '<value is a self-reference, replaced by this string>',
    }
    __match_args__ = (
        'cls',
        'patterns',
        'kwd_attrs',
        'kwd_patterns',
    )


class MatchMapping(__ast.pattern):
    """ MatchMapping(expr* keys, pattern* patterns, identifier? rest) """
    def __init__(self, expr, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    rest = None
    _fields = (
        'keys',
        'patterns',
        'rest',
    )
    _field_types = {
        'keys': list[ast.expr],
        'patterns': list[ast.pattern],
        'rest': str | None,
    }
    __annotations__ = {
        'keys': list[ast.expr],
        'patterns': list[ast.pattern],
        'rest': str | None,
    }
    __match_args__ = (
        'keys',
        'patterns',
        'rest',
    )


class MatchOr(__ast.pattern):
    """ MatchOr(pattern* patterns) """
    def __init__(self, pattern, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    _fields = (
        'patterns',
    )
    _field_types = {
        'patterns': list[ast.pattern],
    }
    __annotations__ = {
        'patterns': list[ast.pattern],
    }
    __match_args__ = (
        'patterns',
    )


class MatchSequence(__ast.pattern):
    """ MatchSequence(pattern* patterns) """
    def __init__(self, pattern, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    _fields = (
        'patterns',
    )
    _field_types = {
        'patterns': list[ast.pattern],
    }
    __annotations__ = {
        'patterns': list[ast.pattern],
    }
    __match_args__ = (
        'patterns',
    )


class MatchSingleton(__ast.pattern):
    """ MatchSingleton(constant value) """
    def __init__(self, constant_value): # real signature unknown; restored from __doc__
        pass

    _fields = (
        'value',
    )
    _field_types = {
        'value': object,
    }
    __annotations__ = {
        'value': object,
    }
    __match_args__ = (
        'value',
    )


class MatchStar(__ast.pattern):
    """ MatchStar(identifier? name) """
    def __init__(self, identifier, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    name = None
    _fields = (
        'name',
    )
    _field_types = {
        'name': str | None,
    }
    __annotations__ = {
        'name': str | None,
    }
    __match_args__ = (
        'name',
    )


class MatchValue(__ast.pattern):
    """ MatchValue(expr value) """
    def __init__(self, expr_value): # real signature unknown; restored from __doc__
        pass

    _fields = (
        'value',
    )
    _field_types = {
        'value': expr,
    }
    __annotations__ = {
        'value': expr,
    }
    __match_args__ = (
        'value',
    )


class match_case(__ast.AST):
    """ match_case(pattern pattern, expr? guard, stmt* body) """
    def __init__(self, pattern_pattern, expr, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    __weakref__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """list of weak references to the object"""


    guard = None
    _attributes = ()
    _fields = (
        'pattern',
        'guard',
        'body',
    )
    _field_types = {
        'body': list[ast.stmt],
        'guard': ast.expr | None,
        'pattern': pattern,
    }
    __annotations__ = {
        'body': list[ast.stmt],
        'guard': ast.expr | None,
        'pattern': pattern,
    }
    __match_args__ = (
        'pattern',
        'guard',
        'body',
    )


class MatMult(__ast.operator):
    """ MatMult """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    _fields = ()
    _field_types = {}
    __annotations__ = {}
    __match_args__ = ()


class Mod(__ast.operator):
    """ Mod """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    _fields = ()
    _field_types = {}
    __annotations__ = {}
    __match_args__ = ()


class Module(__ast.mod):
    """ Module(stmt* body, type_ignore* type_ignores) """
    def __init__(self, stmt, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    _fields = (
        'body',
        'type_ignores',
    )
    _field_types = {
        'body': list[ast.stmt],
        'type_ignores': list[ast.type_ignore],
    }
    __annotations__ = {
        'body': list[ast.stmt],
        'type_ignores': list[ast.type_ignore],
    }
    __match_args__ = (
        'body',
        'type_ignores',
    )


class Mult(__ast.operator):
    """ Mult """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    _fields = ()
    _field_types = {}
    __annotations__ = {}
    __match_args__ = ()


class Name(__ast.expr):
    """ Name(identifier id, expr_context ctx) """
    def __init__(self, identifier_id, expr_context_ctx): # real signature unknown; restored from __doc__
        pass

    _fields = (
        'id',
        'ctx',
    )
    _field_types = {
        'ctx': expr_context,
        'id': str,
    }
    __annotations__ = {
        'ctx': expr_context,
        'id': str,
    }
    __match_args__ = (
        'id',
        'ctx',
    )


class NamedExpr(__ast.expr):
    """ NamedExpr(expr target, expr value) """
    def __init__(self, expr_target, expr_value): # real signature unknown; restored from __doc__
        pass

    _fields = (
        'target',
        'value',
    )
    _field_types = {
        'target': expr,
        'value': '<value is a self-reference, replaced by this string>',
    }
    __annotations__ = {
        'target': expr,
        'value': '<value is a self-reference, replaced by this string>',
    }
    __match_args__ = (
        'target',
        'value',
    )


class Nonlocal(__ast.stmt):
    """ Nonlocal(identifier* names) """
    def __init__(self, identifier, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    _fields = (
        'names',
    )
    _field_types = {
        'names': list[str],
    }
    __annotations__ = {
        'names': list[str],
    }
    __match_args__ = (
        'names',
    )


class Not(__ast.unaryop):
    """ Not """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    _fields = ()
    _field_types = {}
    __annotations__ = {}
    __match_args__ = ()


class NotEq(__ast.cmpop):
    """ NotEq """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    _fields = ()
    _field_types = {}
    __annotations__ = {}
    __match_args__ = ()


class NotIn(__ast.cmpop):
    """ NotIn """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    _fields = ()
    _field_types = {}
    __annotations__ = {}
    __match_args__ = ()


class Or(__ast.boolop):
    """ Or """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    _fields = ()
    _field_types = {}
    __annotations__ = {}
    __match_args__ = ()


class type_param(__ast.AST):
    """
    type_param = TypeVar(identifier name, expr? bound, expr? default_value)
               | ParamSpec(identifier name, expr? default_value)
               | TypeVarTuple(identifier name, expr? default_value)
    """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    __weakref__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """list of weak references to the object"""


    _attributes = (
        'lineno',
        'col_offset',
        'end_lineno',
        'end_col_offset',
    )
    _fields = ()
    __match_args__ = ()


class ParamSpec(__ast.type_param):
    """ ParamSpec(identifier name, expr? default_value) """
    def __init__(self, identifier_name, expr, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    default_value = None
    _fields = (
        'name',
        'default_value',
    )
    _field_types = {
        'default_value': ast.expr | None,
        'name': str,
    }
    __annotations__ = {
        'default_value': ast.expr | None,
        'name': str,
    }
    __match_args__ = (
        'name',
        'default_value',
    )


class Pass(__ast.stmt):
    """ Pass """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    _fields = ()
    _field_types = {}
    __annotations__ = {}
    __match_args__ = ()


class Pow(__ast.operator):
    """ Pow """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    _fields = ()
    _field_types = {}
    __annotations__ = {}
    __match_args__ = ()


class Raise(__ast.stmt):
    """ Raise(expr? exc, expr? cause) """
    def __init__(self, expr, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    cause = None
    exc = None
    _fields = (
        'exc',
        'cause',
    )
    _field_types = {
        'cause': ast.expr | None,
        'exc': '<value is a self-reference, replaced by this string>',
    }
    __annotations__ = {
        'cause': ast.expr | None,
        'exc': '<value is a self-reference, replaced by this string>',
    }
    __match_args__ = (
        'exc',
        'cause',
    )


class Return(__ast.stmt):
    """ Return(expr? value) """
    def __init__(self, expr, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    value = None
    _fields = (
        'value',
    )
    _field_types = {
        'value': ast.expr | None,
    }
    __annotations__ = {
        'value': ast.expr | None,
    }
    __match_args__ = (
        'value',
    )


class RShift(__ast.operator):
    """ RShift """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    _fields = ()
    _field_types = {}
    __annotations__ = {}
    __match_args__ = ()


class Set(__ast.expr):
    """ Set(expr* elts) """
    def __init__(self, expr, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    _fields = (
        'elts',
    )
    _field_types = {
        'elts': list[ast.expr],
    }
    __annotations__ = {
        'elts': list[ast.expr],
    }
    __match_args__ = (
        'elts',
    )


class SetComp(__ast.expr):
    """ SetComp(expr elt, comprehension* generators) """
    def __init__(self, expr_elt, comprehension, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    _fields = (
        'elt',
        'generators',
    )
    _field_types = {
        'elt': expr,
        'generators': list[ast.comprehension],
    }
    __annotations__ = {
        'elt': expr,
        'generators': list[ast.comprehension],
    }
    __match_args__ = (
        'elt',
        'generators',
    )


class Slice(__ast.expr):
    """ Slice(expr? lower, expr? upper, expr? step) """
    def __init__(self, expr, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    lower = None
    step = None
    upper = None
    _fields = (
        'lower',
        'upper',
        'step',
    )
    _field_types = {
        'lower': ast.expr | None,
        'step': '<value is a self-reference, replaced by this string>',
        'upper': '<value is a self-reference, replaced by this string>',
    }
    __annotations__ = {
        'lower': ast.expr | None,
        'step': '<value is a self-reference, replaced by this string>',
        'upper': '<value is a self-reference, replaced by this string>',
    }
    __match_args__ = (
        'lower',
        'upper',
        'step',
    )


class Starred(__ast.expr):
    """ Starred(expr value, expr_context ctx) """
    def __init__(self, expr_value, expr_context_ctx): # real signature unknown; restored from __doc__
        pass

    _fields = (
        'value',
        'ctx',
    )
    _field_types = {
        'ctx': expr_context,
        'value': expr,
    }
    __annotations__ = {
        'ctx': expr_context,
        'value': expr,
    }
    __match_args__ = (
        'value',
        'ctx',
    )


class Store(__ast.expr_context):
    """ Store """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    _fields = ()
    _field_types = {}
    __annotations__ = {}
    __match_args__ = ()


class Sub(__ast.operator):
    """ Sub """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    _fields = ()
    _field_types = {}
    __annotations__ = {}
    __match_args__ = ()


class Subscript(__ast.expr):
    """ Subscript(expr value, expr slice, expr_context ctx) """
    def __init__(self, expr_value, expr_slice, expr_context_ctx): # real signature unknown; restored from __doc__
        pass

    _fields = (
        'value',
        'slice',
        'ctx',
    )
    _field_types = {
        'ctx': expr_context,
        'slice': expr,
        'value': '<value is a self-reference, replaced by this string>',
    }
    __annotations__ = {
        'ctx': expr_context,
        'slice': expr,
        'value': '<value is a self-reference, replaced by this string>',
    }
    __match_args__ = (
        'value',
        'slice',
        'ctx',
    )


class Try(__ast.stmt):
    """ Try(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody) """
    def __init__(self, stmt, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    _fields = (
        'body',
        'handlers',
        'orelse',
        'finalbody',
    )
    _field_types = {
        'body': list[ast.stmt],
        'finalbody': '<value is a self-reference, replaced by this string>',
        'handlers': list[ast.excepthandler],
        'orelse': '<value is a self-reference, replaced by this string>',
    }
    __annotations__ = {
        'body': list[ast.stmt],
        'finalbody': '<value is a self-reference, replaced by this string>',
        'handlers': list[ast.excepthandler],
        'orelse': '<value is a self-reference, replaced by this string>',
    }
    __match_args__ = (
        'body',
        'handlers',
        'orelse',
        'finalbody',
    )


class TryStar(__ast.stmt):
    """ TryStar(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody) """
    def __init__(self, stmt, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    _fields = (
        'body',
        'handlers',
        'orelse',
        'finalbody',
    )
    _field_types = {
        'body': list[ast.stmt],
        'finalbody': '<value is a self-reference, replaced by this string>',
        'handlers': list[ast.excepthandler],
        'orelse': '<value is a self-reference, replaced by this string>',
    }
    __annotations__ = {
        'body': list[ast.stmt],
        'finalbody': '<value is a self-reference, replaced by this string>',
        'handlers': list[ast.excepthandler],
        'orelse': '<value is a self-reference, replaced by this string>',
    }
    __match_args__ = (
        'body',
        'handlers',
        'orelse',
        'finalbody',
    )


class Tuple(__ast.expr):
    """ Tuple(expr* elts, expr_context ctx) """
    def __init__(self, expr, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    dims = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Deprecated. Use elts instead."""


    _fields = (
        'elts',
        'ctx',
    )
    _field_types = {
        'ctx': expr_context,
        'elts': list[ast.expr],
    }
    __annotations__ = {
        'ctx': expr_context,
        'elts': list[ast.expr],
    }
    __match_args__ = (
        'elts',
        'ctx',
    )


class TypeAlias(__ast.stmt):
    """ TypeAlias(expr name, type_param* type_params, expr value) """
    def __init__(self, expr_name, type_param, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    _fields = (
        'name',
        'type_params',
        'value',
    )
    _field_types = {
        'name': expr,
        'type_params': list[ast.type_param],
        'value': '<value is a self-reference, replaced by this string>',
    }
    __annotations__ = {
        'name': expr,
        'type_params': list[ast.type_param],
        'value': '<value is a self-reference, replaced by this string>',
    }
    __match_args__ = (
        'name',
        'type_params',
        'value',
    )


class type_ignore(__ast.AST):
    """ type_ignore = TypeIgnore(int lineno, string tag) """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    __weakref__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """list of weak references to the object"""


    _attributes = ()
    _fields = ()
    __match_args__ = ()


class TypeIgnore(__ast.type_ignore):
    """ TypeIgnore(int lineno, string tag) """
    def __init__(self, int_lineno, string_tag): # real signature unknown; restored from __doc__
        pass

    _fields = (
        'lineno',
        'tag',
    )
    _field_types = {
        'lineno': int,
        'tag': str,
    }
    __annotations__ = {
        'lineno': int,
        'tag': str,
    }
    __match_args__ = (
        'lineno',
        'tag',
    )


class TypeVar(__ast.type_param):
    """ TypeVar(identifier name, expr? bound, expr? default_value) """
    def __init__(self, identifier_name, expr, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    bound = None
    default_value = None
    _fields = (
        'name',
        'bound',
        'default_value',
    )
    _field_types = {
        'bound': ast.expr | None,
        'default_value': '<value is a self-reference, replaced by this string>',
        'name': str,
    }
    __annotations__ = {
        'bound': ast.expr | None,
        'default_value': '<value is a self-reference, replaced by this string>',
        'name': str,
    }
    __match_args__ = (
        'name',
        'bound',
        'default_value',
    )


class TypeVarTuple(__ast.type_param):
    """ TypeVarTuple(identifier name, expr? default_value) """
    def __init__(self, identifier_name, expr, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    default_value = None
    _fields = (
        'name',
        'default_value',
    )
    _field_types = {
        'default_value': ast.expr | None,
        'name': str,
    }
    __annotations__ = {
        'default_value': ast.expr | None,
        'name': str,
    }
    __match_args__ = (
        'name',
        'default_value',
    )


class UAdd(__ast.unaryop):
    """ UAdd """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    _fields = ()
    _field_types = {}
    __annotations__ = {}
    __match_args__ = ()


class UnaryOp(__ast.expr):
    """ UnaryOp(unaryop op, expr operand) """
    def __init__(self, unaryop_op, expr_operand): # real signature unknown; restored from __doc__
        pass

    _fields = (
        'op',
        'operand',
    )
    _field_types = {
        'op': unaryop,
        'operand': expr,
    }
    __annotations__ = {
        'op': unaryop,
        'operand': expr,
    }
    __match_args__ = (
        'op',
        'operand',
    )


class USub(__ast.unaryop):
    """ USub """
    def __init__(self, *args, **kwargs): # real signature unknown
        pass

    _fields = ()
    _field_types = {}
    __annotations__ = {}
    __match_args__ = ()


class While(__ast.stmt):
    """ While(expr test, stmt* body, stmt* orelse) """
    def __init__(self, expr_test, stmt, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    _fields = (
        'test',
        'body',
        'orelse',
    )
    _field_types = {
        'body': list[ast.stmt],
        'orelse': '<value is a self-reference, replaced by this string>',
        'test': expr,
    }
    __annotations__ = {
        'body': list[ast.stmt],
        'orelse': '<value is a self-reference, replaced by this string>',
        'test': expr,
    }
    __match_args__ = (
        'test',
        'body',
        'orelse',
    )


class With(__ast.stmt):
    """ With(withitem* items, stmt* body, string? type_comment) """
    def __init__(self, withitem, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    type_comment = None
    _fields = (
        'items',
        'body',
        'type_comment',
    )
    _field_types = {
        'body': list[ast.stmt],
        'items': list[ast.withitem],
        'type_comment': str | None,
    }
    __annotations__ = {
        'body': list[ast.stmt],
        'items': list[ast.withitem],
        'type_comment': str | None,
    }
    __match_args__ = (
        'items',
        'body',
        'type_comment',
    )


class withitem(__ast.AST):
    """ withitem(expr context_expr, expr? optional_vars) """
    def __init__(self, expr_context_expr, expr, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    __weakref__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """list of weak references to the object"""


    optional_vars = None
    _attributes = ()
    _fields = (
        'context_expr',
        'optional_vars',
    )
    _field_types = {
        'context_expr': expr,
        'optional_vars': ast.expr | None,
    }
    __annotations__ = {
        'context_expr': expr,
        'optional_vars': ast.expr | None,
    }
    __match_args__ = (
        'context_expr',
        'optional_vars',
    )


class Yield(__ast.expr):
    """ Yield(expr? value) """
    def __init__(self, expr, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        pass

    value = None
    _fields = (
        'value',
    )
    _field_types = {
        'value': ast.expr | None,
    }
    __annotations__ = {
        'value': ast.expr | None,
    }
    __match_args__ = (
        'value',
    )


class YieldFrom(__ast.expr):
    """ YieldFrom(expr value) """
    def __init__(self, expr_value): # real signature unknown; restored from __doc__
        pass

    _fields = (
        'value',
    )
    _field_types = {
        'value': expr,
    }
    __annotations__ = {
        'value': expr,
    }
    __match_args__ = (
        'value',
    )


class __loader__(object):
    """
    Meta path import for built-in modules.
    
    All methods are either class or static methods to avoid the need to
    instantiate the class.
    """
    def create_module(spec): # reliably restored by inspect
        """ Create a built-in module """
        pass

    def exec_module(module): # reliably restored by inspect
        """ Exec a built-in module """
        pass

    @classmethod
    def find_spec(cls, *args, **kwargs): # real signature unknown
        pass

    @classmethod
    def get_code(cls, *args, **kwargs): # real signature unknown
        """ Return None as built-in modules do not have code objects. """
        pass

    @classmethod
    def get_source(cls, *args, **kwargs): # real signature unknown
        """ Return None as built-in modules do not have source code. """
        pass

    @classmethod
    def is_package(cls, *args, **kwargs): # real signature unknown
        """ Return False as built-in modules are never packages. """
        pass

    @classmethod
    def load_module(cls, *args, **kwargs): # real signature unknown
        """
        Load the specified module into sys.modules and return it.
        
        This method is deprecated.  Use loader.exec_module() instead.
        """
        pass

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

    __weakref__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """list of weak references to the object"""


    _ORIGIN = 'built-in'
    __dict__ = None # (!) real value is "mappingproxy({'__module__': '_frozen_importlib', '__firstlineno__': 971, '__doc__': 'Meta path import for built-in modules.\\n\\nAll methods are either class or static methods to avoid the need to\\ninstantiate the class.\\n\\n', '_ORIGIN': 'built-in', 'find_spec': <classmethod(<function BuiltinImporter.find_spec at 0x0000023093373380>)>, 'create_module': <staticmethod(<function BuiltinImporter.create_module at 0x0000023093373420>)>, 'exec_module': <staticmethod(<function BuiltinImporter.exec_module at 0x00000230933734C0>)>, 'get_code': <classmethod(<function BuiltinImporter.get_code at 0x0000023093373600>)>, 'get_source': <classmethod(<function BuiltinImporter.get_source at 0x0000023093373740>)>, 'is_package': <classmethod(<function BuiltinImporter.is_package at 0x0000023093373880>)>, 'load_module': <classmethod(<function _load_module_shim at 0x0000023093372700>)>, '__static_attributes__': (), '__dict__': <attribute '__dict__' of 'BuiltinImporter' objects>, '__weakref__': <attribute '__weakref__' of 'BuiltinImporter' objects>})"
    __firstlineno__ = 971
    __static_attributes__ = ()


# variables with complex values

__spec__ = None # (!) real value is "ModuleSpec(name='_ast', loader=<class '_frozen_importlib.BuiltinImporter'>, origin='built-in')"