code: def _type_check_vtable() -> Dict[str, Callable]:
      def _type_check_none(v: Any, name: str) -> Optional[str]:
          return None if v is None else _type_check_err(v, name, None)
  
      def _type_check_atomic(
          v: Any, name: str, type_: Any
      ) -> Optional[str]:
          return (
              None
              if isinstance(v, type_)
              else _type_check_err(v, name, type_)
          )
  
      def _type_check_callable(
          v: Any, name: str, *_subtypes: Any
      ) -> Optional[str]:
          # Current implementation only validates that the argument is
          # callable, and doesn't validate the arguments accepted by the
          # callable, if any.
          return (
              None
              if callable(v)
              else _type_check_err(v, name, Callable)
          )
  
      def _type_check_list(
          v: List[Any], name: str, type_: Any
      ) -> Optional[str]:
          if not isinstance(v, (list, tuple)):
              return _type_check_err(v, name, list)
          for i, x in enumerate(v):
              error_msg = _type_check(x, f"{name}[{i}]", type_)
              if error_msg is not None:
                  return error_msg
          return None
  
      def _type_check_dict(
          dict_obj: Dict[Any, Any], name: str, *types: Any
      ) -> Optional[str]:
          ktype_, vtype_ = types
          if not isinstance(dict_obj, dict):
              return _type_check_err(dict_obj, name, dict)
          for k, v in dict_obj.items():
              error_msg = _type_check(k, f"{name}[{k}]", ktype_)
              if error_msg is not None:
                  return error_msg
              error_msg = _type_check(v, f"{name}[{k}]", vtype_)
              if error_msg is not None:
                  return error_msg
          return None
  
      def _type_check_tuple(
          v: Any, name: str, *types: Any
      ) -> Optional[str]:
          if not isinstance(v, tuple):
              return _type_check_err(v, name, Tuple[types])
          if len(types) != len(v):
              return _type_check_err(v, name, Tuple[types])
          for i, (x, type_) in enumerate(zip(v, types)):
              error_msg = _type_check(x, f"{name}[{i}]", type_)
              if error_msg is not None:
                  return error_msg
          return None
  
      def _type_check_optional(
          v: Any, name: str, type_: Any
      ) -> Optional[str]:
          return None if v is None else _type_check(v, name, type_)
  
      def _type_check_union(
          v: Any, name: str, *types: Any
      ) -> Optional[str]:
          for type_ in types:
              error_msg = _type_check(v, name, type_)
              if error_msg is None:
                  return None
          return _type_check_err(v, name, Union[types])
  
      return {
          "none": _type_check_none,
          "atomic": _type_check_atomic,
          "callable": _type_check_callable,
          "list": _type_check_list,
          "dict": _type_check_dict,
          "tuple": _type_check_tuple,
          "optional": _type_check_optional,
          "union": _type_check_union,
      }
  
file_path: tvm/python/tvm/tir/schedule/_type_checker.py
imports: import collections
  import collections.abc
  import functools
  import inspect
  from typing import Any, Callable, Dict, List, Optional, Tuple, TypeVar, Union
  import typing
label_desc: Use image node_id 8 for calling a global function with example usage: _type_check_vtable() and returns: dict, unknown, unknown, unknown, None, None, None, unknown, _type_check_err, _type_check_err, _type_check_err, _type_check_err, _type_check_err, error_msg, error_msg, error_msg, error_msg, None