class_docstr: Mapping bytecode to ast-node based on the source positions, which where introduced in pyhon 3.11.
  In general every ast-node can be exactly referenced by its begin/end line/col_offset, which is stored in the bytecode.
  There are only some exceptions for methods and attributes.
docstr: checks if this node could gererate this instruction
docstr_tok: ["checks","if","this","node","could","gererate","this","instruction"]
code: def verify(
      self, node: EnhancedAST, instruction: dis.Instruction
  ) -> None:
      """
      checks if this node could gererate this instruction
      """
  
      op_name = instruction.opname
      extra_filter: Callable[[EnhancedAST], bool] = lambda e: True
      ctx: Type = type(None)
  
      def inst_match(
          opnames: Union[str, Sequence[str]], **kwargs: Any
      ) -> bool:
          """
          match instruction
  
          Parameters:
              opnames: (str|Seq[str]): inst.opname has to be equal to or in `opname`
              **kwargs: every arg has to match inst.arg
  
          Returns:
              True if all conditions match the instruction
  
          """
  
          if isinstance(opnames, str):
              opnames = [opnames]
          return instruction.opname in opnames and kwargs == {
              k: getattr(instruction, k) for k in kwargs
          }
  
      def node_match(
          node_type: Union[Type, Tuple[Type, ...]], **kwargs: Any
      ) -> bool:
          """
          match the ast-node
  
          Parameters:
              node_type: type of the node
              **kwargs: every `arg` has to be equal `node.arg`
                      or `node.arg` has to be an instance of `arg` if it is a type.
          """
          return isinstance(node, node_type) and all(
              isinstance(getattr(node, k), v)
              if isinstance(v, type)
              else getattr(node, k) == v
              for k, v in kwargs.items()
          )
  
      if op_name == "CACHE":
          return
  
      if inst_match("CALL") and node_match((ast.With, ast.AsyncWith)):
          # call to context.__exit__
          return
  
      if inst_match(("CALL", "LOAD_FAST")) and node_match(
          (ast.ListComp, ast.GeneratorExp, ast.SetComp, ast.DictComp)
      ):
          # call to the generator function
          return
  
      if (
          sys.version_info >= (3, 12)
          and inst_match(("LOAD_FAST_AND_CLEAR", "STORE_FAST"))
          and node_match((ast.ListComp, ast.SetComp, ast.DictComp))
      ):
          return
  
      if inst_match(("CALL", "CALL_FUNCTION_EX")) and node_match(
          (ast.ClassDef, ast.Call)
      ):
          return
  
      if inst_match(
          ("COMPARE_OP", "IS_OP", "CONTAINS_OP")
      ) and node_match(ast.Compare):
          return
  
      if inst_match(
          "LOAD_NAME", argval="__annotations__"
      ) and node_match(ast.AnnAssign):
          return
  
      if (
          (
              inst_match("LOAD_METHOD", argval="join")
              or inst_match("LOAD_ATTR", argval="join")  # 3.12
              or inst_match(("CALL", "BUILD_STRING"))
          )
          and node_match(ast.BinOp, left=ast.Constant, op=ast.Mod)
          and isinstance(
              cast(ast.Constant, cast(ast.BinOp, node).left).value, str
          )
      ):
          # "..."%(...) uses "".join
          return
  
      if inst_match("STORE_SUBSCR") and node_match(ast.AnnAssign):
          # data: int
          return
  
      if inst_match(("DELETE_NAME", "DELETE_FAST")) and node_match(
          ast.Name, id=instruction.argval, ctx=ast.Del
      ):
          return
  
      if inst_match("BUILD_STRING") and (
          node_match(ast.JoinedStr) or node_match(ast.BinOp, op=ast.Mod)
      ):
          return
  
      if inst_match(
          ("BEFORE_WITH", "WITH_EXCEPT_START")
      ) and node_match(ast.With):
          return
  
      if inst_match(
          ("STORE_NAME", "STORE_GLOBAL"), argval="__doc__"
      ) and node_match(ast.Constant):
          # store docstrings
          return
  
      if (
          inst_match(
              (
                  "STORE_NAME",
                  "STORE_FAST",
                  "STORE_GLOBAL",
                  "STORE_DEREF",
              )
          )
          and node_match(ast.ExceptHandler)
          and instruction.argval == mangled_name(node)
      ):
          # store exception in variable
          return
  
      if (
          inst_match(
              (
                  "STORE_NAME",
                  "STORE_FAST",
                  "STORE_DEREF",
                  "STORE_GLOBAL",
              )
          )
          and node_match((ast.Import, ast.ImportFrom))
          and any(
              mangled_name(cast(EnhancedAST, alias))
              == instruction.argval
              for alias in cast(ast.Import, node).names
          )
      ):
          # store imported module in variable
          return
  
      if (
          inst_match(
              (
                  "STORE_FAST",
                  "STORE_DEREF",
                  "STORE_NAME",
                  "STORE_GLOBAL",
              )
          )
          and (
              node_match(
                  (ast.FunctionDef, ast.ClassDef, ast.AsyncFunctionDef)
              )
              or node_match(
                  ast.Name,
                  ctx=ast.Store,
              )
          )
          and instruction.argval == mangled_name(node)
      ):
          return
  
      if False:
          # TODO: match expressions are not supported for now
          if inst_match(("STORE_FAST", "STORE_NAME")) and node_match(
              ast.MatchAs, name=instruction.argval
          ):
              return
  
          if inst_match("COMPARE_OP", argval="==") and node_match(
              ast.MatchSequence
          ):
              return
  
          if inst_match("COMPARE_OP", argval="==") and node_match(
              ast.MatchValue
          ):
              return
  
      if inst_match("BINARY_OP") and node_match(
          ast.AugAssign,
          op=op_type_map[instruction.argrepr.removesuffix("=")],
      ):
          # a+=5
          return
  
      if node_match(ast.Attribute, ctx=ast.Del) and inst_match(
          "DELETE_ATTR", argval=mangled_name(node)
      ):
          return
  
      if inst_match(
          (
              "JUMP_IF_TRUE_OR_POP",
              "JUMP_IF_FALSE_OR_POP",
              "POP_JUMP_IF_TRUE",
              "POP_JUMP_IF_FALSE",
          )
      ) and node_match(ast.BoolOp):
          # and/or short circuit
          return
  
      if inst_match("DELETE_SUBSCR") and node_match(
          ast.Subscript, ctx=ast.Del
      ):
          return
  
      if (
          node_match(ast.Name, ctx=ast.Load)
          or (
              node_match(ast.Name, ctx=ast.Store)
              and isinstance(node.parent, ast.AugAssign)
          )
      ) and inst_match(
          (
              "LOAD_NAME",
              "LOAD_FAST",
              "LOAD_FAST_CHECK",
              "LOAD_GLOBAL",
              "LOAD_DEREF",
              "LOAD_FROM_DICT_OR_DEREF",
          ),
          argval=mangled_name(node),
      ):
          return
  
      if node_match(ast.Name, ctx=ast.Del) and inst_match(
          ("DELETE_NAME", "DELETE_GLOBAL", "DELETE_DEREF"),
          argval=mangled_name(node),
      ):
          return
  
      if node_match(ast.Constant) and inst_match(
          "LOAD_CONST", argval=cast(ast.Constant, node).value
      ):
          return
  
      if node_match(
          (
              ast.ListComp,
              ast.SetComp,
              ast.DictComp,
              ast.GeneratorExp,
              ast.For,
          )
      ) and inst_match(("GET_ITER", "FOR_ITER")):
          return
  
      if sys.version_info >= (3, 12):
          if node_match(ast.UnaryOp, op=ast.UAdd) and inst_match(
              "CALL_INTRINSIC_1", argrepr="INTRINSIC_UNARY_POSITIVE"
          ):
              return
  
          if node_match(ast.Subscript) and inst_match("BINARY_SLICE"):
              return
  
          if node_match(ast.ImportFrom) and inst_match(
              "CALL_INTRINSIC_1", argrepr="INTRINSIC_IMPORT_STAR"
          ):
              return
  
          if (
              node_match(ast.Yield)
              or isinstance(node.parent, ast.GeneratorExp)
          ) and inst_match(
              "CALL_INTRINSIC_1", argrepr="INTRINSIC_ASYNC_GEN_WRAP"
          ):
              return
  
          if node_match(ast.Name) and inst_match(
              "LOAD_DEREF", argval="__classdict__"
          ):
              return
  
          if node_match(ast.TypeVar) and (
              inst_match(
                  "CALL_INTRINSIC_1", argrepr="INTRINSIC_TYPEVAR"
              )
              or inst_match(
                  "CALL_INTRINSIC_2",
                  argrepr="INTRINSIC_TYPEVAR_WITH_BOUND",
              )
              or inst_match(
                  "CALL_INTRINSIC_2",
                  argrepr="INTRINSIC_TYPEVAR_WITH_CONSTRAINTS",
              )
              or inst_match(
                  ("STORE_FAST", "STORE_DEREF"),
                  argrepr=mangled_name(node),
              )
          ):
              return
  
          if node_match(ast.TypeVarTuple) and (
              inst_match(
                  "CALL_INTRINSIC_1", argrepr="INTRINSIC_TYPEVARTUPLE"
              )
              or inst_match(
                  ("STORE_FAST", "STORE_DEREF"), argrepr=node.name
              )
          ):
              return
  
          if node_match(ast.ParamSpec) and (
              inst_match(
                  "CALL_INTRINSIC_1", argrepr="INTRINSIC_PARAMSPEC"
              )
              or inst_match(
                  ("STORE_FAST", "STORE_DEREF"), argrepr=node.name
              )
          ):
              return
  
          if node_match(ast.TypeAlias):
              if (
                  inst_match(
                      "CALL_INTRINSIC_1", argrepr="INTRINSIC_TYPEALIAS"
                  )
                  or inst_match(
                      ("STORE_NAME", "STORE_FAST", "STORE_DEREF"),
                      argrepr=node.name.id,
                  )
                  or inst_match("CALL")
              ):
                  return
  
          if node_match(ast.ClassDef) and node.type_params:
              if inst_match(
                  (
                      "STORE_DEREF",
                      "LOAD_DEREF",
                      "LOAD_FROM_DICT_OR_DEREF",
                  ),
                  argrepr=".type_params",
              ):
                  return
  
              if inst_match(
                  ("STORE_FAST", "LOAD_FAST"), argrepr=".generic_base"
              ):
                  return
  
              if inst_match(
                  "CALL_INTRINSIC_1",
                  argrepr="INTRINSIC_SUBSCRIPT_GENERIC",
              ):
                  return
  
              if inst_match("LOAD_DEREF", argval="__classdict__"):
                  return
  
          if (
              node_match((ast.FunctionDef, ast.AsyncFunctionDef))
              and node.type_params
          ):
              if inst_match("CALL"):
                  return
  
              if inst_match(
                  "CALL_INTRINSIC_2",
                  argrepr="INTRINSIC_SET_FUNCTION_TYPE_PARAMS",
              ):
                  return
  
              if inst_match("LOAD_FAST", argval=".defaults"):
                  return
  
              if inst_match("LOAD_FAST", argval=".kwdefaults"):
                  return
  
          if inst_match("STORE_NAME", argval="__classdictcell__"):
              # this is a general thing
              return
  
          # f-strings
  
          if node_match(ast.JoinedStr) and (
              inst_match("LOAD_ATTR", argval="join")
              or inst_match(("LIST_APPEND", "CALL"))
          ):
              return
  
          if node_match(ast.FormattedValue) and inst_match(
              "FORMAT_VALUE"
          ):
              return
  
      # old verifier
  
      typ: Type = type(None)
      op_type: Type = type(None)
  
      if op_name.startswith(("BINARY_SUBSCR", "SLICE+")):
          typ = ast.Subscript
          ctx = ast.Load
      elif op_name.startswith("BINARY_"):
          typ = ast.BinOp
          op_type = op_type_map[instruction.argrepr]
          extra_filter = lambda e: isinstance(
              cast(ast.BinOp, e).op, op_type
          )
      elif op_name.startswith("UNARY_"):
          typ = ast.UnaryOp
          op_type = dict(
              UNARY_POSITIVE=ast.UAdd,
              UNARY_NEGATIVE=ast.USub,
              UNARY_NOT=ast.Not,
              UNARY_INVERT=ast.Invert,
          )[op_name]
          extra_filter = lambda e: isinstance(
              cast(ast.UnaryOp, e).op, op_type
          )
      elif op_name in (
          "LOAD_ATTR",
          "LOAD_METHOD",
          "LOOKUP_METHOD",
          "LOAD_SUPER_ATTR",
      ):
          typ = ast.Attribute
          ctx = ast.Load
          extra_filter = lambda e: mangled_name(e) == instruction.argval
      elif op_name in (
          "LOAD_NAME",
          "LOAD_GLOBAL",
          "LOAD_FAST",
          "LOAD_DEREF",
          "LOAD_CLASSDEREF",
      ):
          typ = ast.Name
          ctx = ast.Load
          extra_filter = (
              lambda e: cast(ast.Name, e).id == instruction.argval
          )
      elif op_name in ("COMPARE_OP", "IS_OP", "CONTAINS_OP"):
          typ = ast.Compare
          extra_filter = lambda e: len(cast(ast.Compare, e).ops) == 1
      elif op_name.startswith(("STORE_SLICE", "STORE_SUBSCR")):
          ctx = ast.Store
          typ = ast.Subscript
      elif op_name.startswith("STORE_ATTR"):
          ctx = ast.Store
          typ = ast.Attribute
          extra_filter = lambda e: mangled_name(e) == instruction.argval
  
      node_ctx = getattr(node, "ctx", None)
  
      ctx_match = (
          ctx is not type(None)
          or not hasattr(node, "ctx")
          or isinstance(node_ctx, ctx)
      )
  
      # check for old verifier
      if isinstance(node, typ) and ctx_match and extra_filter(node):
          return
  
      # generate error
  
      title = "ast.%s is not created from %s" % (
          type(node).__name__,
          instruction.opname,
      )
  
      raise VerifierFailure(title, node, instruction)
  
imports: import ast
  import sys
  import dis
  from types import CodeType, FrameType
  from typing import Any, Callable, Iterator, Optional, Sequence, Set, Tuple, Type, Union, cast
  from .executing import EnhancedAST, NotOneValueFound, Source, only, function_node_types, assert_
  from ._exceptions import KnownIssue, VerifierFailure
  from functools import lru_cache
label_desc: Use image node_id 5 for calling the PositionNodeFinder obj's underlying member method code with example usage: obj.verify(node, instruction) and returns: unknown, unknown